Datasets:

---

kejian

/

codesearchnet-python-raw

like 1

[ "def", "full_file_list_with_sequence", "(", "scan_path", ")", ":", "file_list", "=", "[", "]", "path", "=", "os", ".", "path", ".", "abspath", "(", "scan_path", ")", "for", "root", ",", "dirs", ",", "files", "in", "os", ".", "walk", "(", "path", ")", ":", "if", "len", "(", "files", ")", "!=", "0", "and", "not", "'.svn'", "in", "root", "and", "not", "'.git'", "in", "root", ":", "try", ":", "sc", "=", "sequential", ".", "SequentialFolder", "(", "str", "(", "root", ")", ")", "if", "sc", ".", "sequence", ":", "file_list", ".", "append", "(", "sc", ")", "continue", "except", "Exception", "as", "e", ":", "pass", "for", "f", "in", "files", ":", "file_list", ".", "append", "(", "os", ".", "path", ".", "join", "(", "root", ",", "f", ")", ")", "return", "file_list" ]

[ "Returns", "a", "list", "of", "all", "files", "in", "a", "folder", "and", "its", "subfolders", "(", "only", "files", ")", "." ]

[ "def", "get_field", "(", "self", ",", "path", ",", "name", ")", ":", "try", ":", "value", "=", "self", ".", "get", "(", "path", ",", "name", ")", "if", "not", "isinstance", "(", "value", ",", "str", ")", ":", "raise", "TypeError", "(", ")", "return", "value", "except", "KeyError", ":", "raise", "KeyError", "(", ")" ]

[ "Retrieves", "the", "value", "of", "the", "field", "at", "the", "specified", "path", "." ]

[ "def", "load_ini", "(", "filename", ")", ":", "# also look in data dir", "path", "=", "_find_file", "(", "filename", ")", "pars", "=", "{", "}", "with", "open", "(", "path", ",", "'r'", ")", "as", "ff", ":", "# loop over lines", "for", "lineno", ",", "line", "in", "enumerate", "(", "ff", ")", ":", "if", "not", "line", ":", "continue", "# skip any commented lines with #", "if", "'#'", "in", "line", ":", "line", "=", "line", "[", "line", ".", "index", "(", "'#'", ")", "+", "1", ":", "]", "# must have an equals sign to be valid", "if", "\"=\"", "not", "in", "line", ":", "continue", "# extract key and value pairs", "fields", "=", "line", ".", "split", "(", "\"=\"", ")", "if", "len", "(", "fields", ")", "!=", "2", ":", "import", "warnings", "warnings", ".", "warn", "(", "\"skipping line number %d: '%s'\"", "%", "(", "lineno", ",", "line", ")", ")", "continue", "pars", "[", "fields", "[", "0", "]", ".", "strip", "(", ")", "]", "=", "fields", "[", "1", "]", ".", "strip", "(", ")", "return", "pars" ]

[ "Read", "a", "CLASS", ".", "ini", "file", "returning", "a", "dictionary", "of", "parameters" ]

[ "def", "executed_without_callbacks", "(", "self", ")", ":", "T", "=", "self", ".", "tm", ".", "trace", "if", "T", ":", "T", ".", "write", "(", "self", ".", "trace_message", "(", "'Task.executed_without_callbacks()'", ",", "self", ".", "node", ")", ")", "for", "t", "in", "self", ".", "targets", ":", "if", "t", ".", "get_state", "(", ")", "==", "NODE_EXECUTING", ":", "for", "side_effect", "in", "t", ".", "side_effects", ":", "side_effect", ".", "set_state", "(", "NODE_NO_STATE", ")", "t", ".", "set_state", "(", "NODE_EXECUTED", ")" ]

[ "Called", "when", "the", "task", "has", "been", "successfully", "executed", "and", "the", "Taskmaster", "instance", "doesn", "t", "want", "to", "call", "the", "Node", "s", "callback", "methods", "." ]

[ "def", "__GetAuthorizationTokenUsingMasterKey", "(", "verb", ",", "resource_id_or_fullname", ",", "resource_type", ",", "headers", ",", "master_key", ")", ":", "# decodes the master key which is encoded in base64 ", "key", "=", "base64", ".", "b64decode", "(", "master_key", ")", "# Skipping lower casing of resource_id_or_fullname since it may now contain \"ID\" of the resource as part of the fullname", "text", "=", "'{verb}\\n{resource_type}\\n{resource_id_or_fullname}\\n{x_date}\\n{http_date}\\n'", ".", "format", "(", "verb", "=", "(", "verb", ".", "lower", "(", ")", "or", "''", ")", ",", "resource_type", "=", "(", "resource_type", ".", "lower", "(", ")", "or", "''", ")", ",", "resource_id_or_fullname", "=", "(", "resource_id_or_fullname", "or", "''", ")", ",", "x_date", "=", "headers", ".", "get", "(", "http_constants", ".", "HttpHeaders", ".", "XDate", ",", "''", ")", ".", "lower", "(", ")", ",", "http_date", "=", "headers", ".", "get", "(", "http_constants", ".", "HttpHeaders", ".", "HttpDate", ",", "''", ")", ".", "lower", "(", ")", ")", "if", "six", ".", "PY2", ":", "body", "=", "text", ".", "decode", "(", "'utf-8'", ")", "digest", "=", "hmac", ".", "new", "(", "key", ",", "body", ",", "sha256", ")", ".", "digest", "(", ")", "signature", "=", "digest", ".", "encode", "(", "'base64'", ")", "else", ":", "# python 3 support", "body", "=", "text", ".", "encode", "(", "'utf-8'", ")", "digest", "=", "hmac", ".", "new", "(", "key", ",", "body", ",", "sha256", ")", ".", "digest", "(", ")", "signature", "=", "base64", ".", "encodebytes", "(", "digest", ")", ".", "decode", "(", "'utf-8'", ")", "master_token", "=", "'master'", "token_version", "=", "'1.0'", "return", "'type={type}&ver={ver}&sig={sig}'", ".", "format", "(", "type", "=", "master_token", ",", "ver", "=", "token_version", ",", "sig", "=", "signature", "[", ":", "-", "1", "]", ")" ]

[ "Gets", "the", "authorization", "token", "using", "master_key", "." ]

[ "def", "check_power_redundancy", "(", ")", ":", "# skip the check if --noPowerRedundancy is set", "if", "power_redundancy_flag", ":", "# walk the data ", "ps_redundant_data", "=", "walk_data", "(", "sess", ",", "oid_ps_redundant", ",", "helper", ")", "[", "0", "]", "for", "x", ",", "state", "in", "enumerate", "(", "ps_redundant_data", ",", "1", ")", ":", "# human readable status", "hr_status", "=", "ps_redundant_state", "[", "int", "(", "state", ")", "]", "if", "hr_status", "!=", "\"redundant\"", ":", "# if the power supply is not redundant, we will set a critical status and add it to the summary", "helper", ".", "add_summary", "(", "'Power supply %s: %s'", "%", "(", "x", ",", "hr_status", ")", ")", "helper", ".", "status", "(", "critical", ")", "# we always want to see the redundancy status in the long output", "helper", ".", "add_long_output", "(", "'Power supply %s: %s'", "%", "(", "x", ",", "hr_status", ")", ")", "helper", ".", "add_long_output", "(", "''", ")" ]

[ "Check", "if", "the", "power", "supplies", "are", "redundant", "The", "check", "is", "skipped", "if", "--", "noPowerRedundancy", "is", "set" ]

[ "def", "parse_namespace", "(", "parser", ",", "event", ",", "node", ")", ":", "#pylint: disable=unused-argument", "name", "=", "_get_required_attribute", "(", "node", ",", "'NAME'", ")", "(", "next_event", ",", "next_node", ")", "=", "six", ".", "next", "(", "parser", ")", "if", "not", "_is_end", "(", "next_event", ",", "next_node", ",", "'NAMESPACE'", ")", ":", "raise", "ParseError", "(", "'Expecting end NAMESPACE'", ")", "return", "name" ]

[ "Parse", "the", "CIM", "/", "XML", "NAMESPACE", "element", "and", "return", "the", "value", "of", "the", "CIMName", "attribute", "<!ELEMENT", "NAMESPACE", "EMPTY", ">", "<!ATTLIST", "NAMESPACE", "%CIMName", ";" ]

[ "def", "split_addrs", "(", "addrs", ")", ":", "splitted", "=", "{", "}", "for", "addr", "in", "addrs", ":", "host", ",", "port", ",", "_", "=", "_addr_key", "(", "addr", ")", "if", "host", "not", "in", "splitted", ":", "splitted", "[", "host", "]", "=", "{", "}", "if", "port", "not", "in", "splitted", "[", "host", "]", ":", "splitted", "[", "host", "]", "[", "port", "]", "=", "[", "]", "splitted", "[", "host", "]", "[", "port", "]", ".", "append", "(", "addr", ")", "return", "splitted" ]

[ "Split", "addresses", "into", "dictionaries", "by", "hosts", "and", "ports", "." ]

[ "def", "request_get_variable_json", "(", "self", ",", "py_db", ",", "request", ",", "thread_id", ")", ":", "py_db", ".", "post_method_as_internal_command", "(", "thread_id", ",", "internal_get_variable_json", ",", "request", ")" ]

[ ":", "param", "VariablesRequest", "request", ":" ]

[ "def", "main", "(", "argv", "=", "None", ")", ":", "if", "argv", "is", "None", ":", "argv", "=", "sys", ".", "argv", "[", "1", ":", "]", "cli", "=", "CommandLineTool", "(", ")", "try", ":", "return", "cli", ".", "run", "(", "argv", ")", "except", "KeyboardInterrupt", ":", "print", "(", "'Canceled'", ")", "return", "3" ]

[ "Main", "command", "line", "interface", "." ]

[ "def", "count_slow", "(", "self", ",", "page_size", "=", "10", ",", "vtimeout", "=", "10", ")", ":", "n", "=", "0", "l", "=", "self", ".", "get_messages", "(", "page_size", ",", "vtimeout", ")", "while", "l", ":", "for", "m", "in", "l", ":", "n", "+=", "1", "l", "=", "self", ".", "get_messages", "(", "page_size", ",", "vtimeout", ")", "return", "n" ]

[ "Deprecated", ".", "This", "is", "the", "old", "count", "method", "that", "actually", "counts", "the", "messages", "by", "reading", "them", "all", ".", "This", "gives", "an", "accurate", "count", "but", "is", "very", "slow", "for", "queues", "with", "non", "-", "trivial", "number", "of", "messasges", ".", "Instead", "use", "get_attribute", "(", "ApproximateNumberOfMessages", ")", "to", "take", "advantage", "of", "the", "new", "SQS", "capability", ".", "This", "is", "retained", "only", "for", "the", "unit", "tests", "." ]

[ "def", "best_buy_3", "(", "self", ")", ":", "return", "self", ".", "data", ".", "continuous", "(", "self", ".", "data", ".", "moving_average", "(", "self", ".", "data", ".", "price", ",", "3", ")", ")", "==", "1" ]

[ "三日均價由下往上" ]

[ "def", "_get_link_pages", "(", "page", ",", "per_page", ",", "count", ",", "page_url", ")", ":", "# type: (int, int, int, str) -> Dict[str, str]", "current_page", "=", "_page_arg", "(", "page", ")", "links", "=", "{", "}", "end", "=", "page", "*", "per_page", "if", "page", ">", "1", ":", "links", "[", "'prev'", "]", "=", "page_url", ".", "replace", "(", "current_page", ",", "_page_arg", "(", "page", "-", "1", ")", ")", "if", "end", "<", "count", ":", "links", "[", "'next'", "]", "=", "page_url", ".", "replace", "(", "current_page", ",", "_page_arg", "(", "page", "+", "1", ")", ")", "if", "per_page", "<", "count", ":", "links", "[", "'first'", "]", "=", "page_url", ".", "replace", "(", "current_page", ",", "_page_arg", "(", "1", ")", ")", "links", "[", "'last'", "]", "=", "page_url", ".", "replace", "(", "current_page", ",", "_page_arg", "(", "(", "count", "+", "per_page", "-", "1", ")", "//", "per_page", ")", ")", "return", "links" ]

[ "Create", "link", "header", "for", "page", "metadata", "." ]

[ "def", "InterpolateGrouping", "(", "self", ",", "pattern", ")", ":", "components", "=", "[", "]", "offset", "=", "0", "for", "match", "in", "GROUPING_PATTERN", ".", "finditer", "(", "pattern", ")", ":", "components", ".", "append", "(", "[", "pattern", "[", "offset", ":", "match", ".", "start", "(", ")", "]", "]", ")", "# Expand the attribute into the set of possibilities:", "alternatives", "=", "match", ".", "group", "(", "1", ")", ".", "split", "(", "\",\"", ")", "components", ".", "append", "(", "set", "(", "alternatives", ")", ")", "offset", "=", "match", ".", "end", "(", ")", "components", ".", "append", "(", "[", "pattern", "[", "offset", ":", "]", "]", ")", "# Now calculate the cartesian products of all these sets to form all", "# strings.", "for", "vector", "in", "itertools", ".", "product", "(", "*", "components", ")", ":", "yield", "u\"\"", ".", "join", "(", "vector", ")" ]

[ "Interpolate", "inline", "globbing", "groups", "." ]

[ "def", "unix_install", "(", ")", ":", "PmagPyDir", "=", "os", ".", "path", ".", "abspath", "(", "\".\"", ")", "COMMAND", "=", "\"\"\"\\n\nfor d in %s/programs/*/ \"%s/programs/\"; do\n case \":$PATH:\" in\n *\":$d:\"*) :;; # already there\n *) PMAGPATHS=\"$PMAGPATHS:$d\";; # or PATH=\"$PATH:$new_entry\"\n esac\ndone\nexport PYTHONPATH=\"$PYTHONPATH:%s:%s/programs/\"\nexport PATH=\"$PATH:$PMAGPATHS\" \"\"\"", "%", "(", "PmagPyDir", ",", "PmagPyDir", ",", "PmagPyDir", ",", "PmagPyDir", ")", "frc_path", "=", "os", ".", "path", ".", "join", "(", "os", ".", "environ", "[", "\"HOME\"", "]", ",", "\".bashrc\"", ")", "# not recommended, but hey it freaking works", "fbprof_path", "=", "os", ".", "path", ".", "join", "(", "os", ".", "environ", "[", "\"HOME\"", "]", ",", "\".bash_profile\"", ")", "fprof_path", "=", "os", ".", "path", ".", "join", "(", "os", ".", "environ", "[", "\"HOME\"", "]", ",", "\".profile\"", ")", "all_paths", "=", "[", "frc_path", ",", "fbprof_path", ",", "fprof_path", "]", "for", "f_path", "in", "all_paths", ":", "open_type", "=", "'a'", "if", "not", "os", ".", "path", ".", "isfile", "(", "f_path", ")", ":", "open_type", "=", "'w+'", "fout", "=", "open", "(", "f_path", ",", "open_type", ")", "fout", ".", "write", "(", "COMMAND", ")", "fout", ".", "close", "(", ")", "else", ":", "fin", "=", "open", "(", "f_path", ",", "'r'", ")", "current_f", "=", "fin", ".", "read", "(", ")", "fin", ".", "close", "(", ")", "if", "COMMAND", "not", "in", "current_f", ":", "fout", "=", "open", "(", "f_path", ",", "open_type", ")", "fout", ".", "write", "(", "COMMAND", ")", "fout", ".", "close", "(", ")", "print", "(", "\"Install complete. Please restart the shell to complete install.\\nIf you are seeing strange or non-existent paths in your PATH or PYTHONPATH variable please manually check your .bashrc, .bash_profile, and .profile or attempt to reinstall.\"", ")" ]

[ "Edits", "or", "creates", ".", "bashrc", ".", "bash_profile", "and", ".", "profile", "files", "in", "the", "users", "HOME", "directory", "in", "order", "to", "add", "your", "current", "directory", "(", "hopefully", "your", "PmagPy", "directory", ")", "and", "assorted", "lower", "directories", "in", "the", "PmagPy", "/", "programs", "directory", "to", "your", "PATH", "environment", "variable", ".", "It", "also", "adds", "the", "PmagPy", "and", "the", "PmagPy", "/", "programs", "directories", "to", "PYTHONPATH", "." ]

[ "def", "choicerank", "(", "digraph", ",", "traffic_in", ",", "traffic_out", ",", "weight", "=", "None", ",", "initial_params", "=", "None", ",", "alpha", "=", "1.0", ",", "max_iter", "=", "10000", ",", "tol", "=", "1e-8", ")", ":", "import", "networkx", "as", "nx", "# Compute the (sparse) adjacency matrix.", "n_items", "=", "len", "(", "digraph", ")", "nodes", "=", "np", ".", "arange", "(", "n_items", ")", "adj", "=", "nx", ".", "to_scipy_sparse_matrix", "(", "digraph", ",", "nodelist", "=", "nodes", ",", "weight", "=", "weight", ")", "adj_t", "=", "adj", ".", "T", ".", "tocsr", "(", ")", "# Process the data into a standard form.", "traffic_in", "=", "np", ".", "asarray", "(", "traffic_in", ")", "traffic_out", "=", "np", ".", "asarray", "(", "traffic_out", ")", "data", "=", "(", "adj", ",", "adj_t", ",", "traffic_in", ",", "traffic_out", ")", "return", "_mm", "(", "n_items", ",", "data", ",", "initial_params", ",", "alpha", ",", "max_iter", ",", "tol", ",", "_choicerank", ")" ]

[ "Compute", "the", "MAP", "estimate", "of", "a", "network", "choice", "model", "s", "parameters", "." ]

[ "def", "load_config", "(", "files", "=", "None", ",", "root_path", "=", "None", ",", "local_path", "=", "None", ")", ":", "config", "=", "cfg", ".", "ConfigOpts", "(", ")", "config", ".", "register_opts", "(", "[", "cfg", ".", "Opt", "(", "'root_path'", ",", "default", "=", "root_path", ")", ",", "cfg", ".", "Opt", "(", "'local_path'", ",", "default", "=", "local_path", ")", ",", "]", ")", "# XXX register actual config groups here", "# theme_group = config_theme.register_config(config)", "if", "files", "is", "not", "None", ":", "config", "(", "args", "=", "[", "]", ",", "default_config_files", "=", "files", ")", "return", "config" ]

[ "Load", "the", "configuration", "from", "specified", "files", "." ]

[ "def", "bet_cancel", "(", "self", ",", "bet_to_cancel", ",", "account", "=", "None", ",", "*", "*", "kwargs", ")", ":", "if", "not", "account", ":", "if", "\"default_account\"", "in", "self", ".", "config", ":", "account", "=", "self", ".", "config", "[", "\"default_account\"", "]", "if", "not", "account", ":", "raise", "ValueError", "(", "\"You need to provide an account\"", ")", "account", "=", "Account", "(", "account", ")", "bet", "=", "Bet", "(", "bet_to_cancel", ")", "op", "=", "operations", ".", "Bet_cancel", "(", "*", "*", "{", "\"fee\"", ":", "{", "\"amount\"", ":", "0", ",", "\"asset_id\"", ":", "\"1.3.0\"", "}", ",", "\"bettor_id\"", ":", "account", "[", "\"id\"", "]", ",", "\"bet_to_cancel\"", ":", "bet", "[", "\"id\"", "]", ",", "\"prefix\"", ":", "self", ".", "prefix", ",", "}", ")", "return", "self", ".", "finalizeOp", "(", "op", ",", "account", "[", "\"name\"", "]", ",", "\"active\"", ",", "*", "*", "kwargs", ")" ]

[ "Cancel", "a", "bet" ]

[ "def", "button", "(", "self", ",", "name", ",", "filename", ",", "command", ")", ":", "try", ":", "img", "=", "LoadImage", "(", "filename", ")", "b", "=", "Tkinter", ".", "Button", "(", "self", ".", "frame", ",", "image", "=", "img", ",", "command", "=", "command", ")", "b", ".", "image", "=", "img", "except", "Exception", ":", "b", "=", "Tkinter", ".", "Button", "(", "self", ".", "frame", ",", "text", "=", "filename", ",", "command", "=", "command", ")", "b", ".", "pack", "(", "side", "=", "Tkinter", ".", "LEFT", ")", "self", ".", "buttons", "[", "name", "]", "=", "b" ]

[ "add", "a", "button" ]

[ "def", "merge_dicts", "(", "*", "dicts", ")", ":", "def", "_merge_dicts", "(", "dict1", ",", "dict2", ")", ":", "merged", "=", "dict1", ".", "copy", "(", ")", "merged", ".", "update", "(", "dict2", ")", "return", "merged", "return", "reduce", "(", "_merge_dicts", ",", "dicts", ")" ]

[ "Helpful", "function", "to", "merge", "/", "combine", "dictionaries", "and", "return", "a", "new", "dictionary", "." ]

[ "def", "check_missing_atoms", "(", "self", ",", "template", "=", "None", ",", "ha_only", "=", "True", ")", ":", "missing_atoms", "=", "{", "}", "if", "not", "template", ":", "import", "protein_residues", "template", "=", "protein_residues", ".", "normal", "# Don't care for terminal residues here..", "for", "residue", "in", "self", ".", "get_residues", "(", ")", ":", "if", "not", "template", ".", "has_key", "(", "residue", ".", "resname", ")", ":", "# Maybe add this as a warning instead of exception?", "raise", "ValueError", "(", "'Residue name (%s) not in the template'", "%", "residue", ".", "resname", ")", "if", "ha_only", ":", "heavy_atoms", "=", "[", "atom", "for", "atom", "in", "template", "[", "residue", ".", "resname", "]", "[", "'atoms'", "]", ".", "keys", "(", ")", "if", "atom", "[", "0", "]", "!=", "'H'", "and", "not", "(", "atom", "[", "0", "]", ".", "isdigit", "(", ")", "and", "atom", "[", "1", "]", "==", "'H'", ")", "]", "reference_set", "=", "set", "(", "heavy_atoms", ")", "else", ":", "reference_set", "=", "set", "(", "template", "[", "residue", ".", "resname", "]", "[", "'atoms'", "]", ".", "keys", "(", ")", ")", "structure_set", "=", "set", "(", "residue", ".", "child_dict", ".", "keys", "(", ")", ")", "diff", "=", "reference_set", ".", "difference", "(", "structure_set", ")", "if", "diff", ":", "residue_uniq_id", "=", "(", "residue", ".", "parent", ".", "id", ",", "residue", ".", "resname", ",", "residue", ".", "get_id", "(", ")", "[", "1", "]", ")", "# Chain, Name, Number", "missing_atoms", "[", "residue_uniq_id", "]", "=", "list", "(", "diff", ")", "return", "missing_atoms" ]

[ "Checks", "for", "missing", "atoms", "based", "on", "a", "template", ".", "Default", ":", "Searches", "for", "missing", "heavy", "atoms", "(", "not", "Hydrogen", ")", "based", "on", "Bio", ".", "Struct", ".", "protein_residues", "Arguments", ":", "-", "template", "dictionary", "keys", "are", "residue", "names", "values", "list", "of", "atom", "names", ".", "-", "ha_only", "boolean", "default", "True", "restrict", "check", "to", "heavy", "atoms", ".", "Returns", "a", "dictionary", "of", "tuples", "with", "the", "missing", "atoms", "per", "residue", "." ]

[ "def", "time_report_item", "(", "self", ",", "label", ",", "message", "=", "None", ")", ":", "next_", "=", "TIMESTAMPS_ORDER", "[", "TIMESTAMPS_ORDER", ".", "index", "(", "label", ")", "+", "1", "]", "while", "next_", "not", "in", "self", ".", "_timestamps", ":", "next_", "=", "TIMESTAMPS_ORDER", "[", "TIMESTAMPS_ORDER", ".", "index", "(", "next_", ")", "+", "1", "]", "assert", "label", "in", "TIMESTAMPS_ORDER", "start", "=", "self", ".", "_timestamps", "[", "label", "]", "-", "self", ".", "_timestamps", "[", "TIMESTAMPS_ORDER", "[", "0", "]", "]", "end", "=", "self", ".", "_timestamps", "[", "next_", "]", "-", "self", ".", "_timestamps", "[", "TIMESTAMPS_ORDER", "[", "0", "]", "]", "return", "{", "'Message'", ":", "message", ",", "'Start'", ":", "start", ",", "'End'", ":", "end", ",", "'Sum'", ":", "end", "-", "start", ",", "'Count'", ":", "1", "}" ]

[ "This", "will", "return", "a", "dictionary", "for", "the", "given", "message", "based", "on", "timestamps", ":", "param", "label", ":", ":", "param", "message", ":", "str", "of", "the", "message", "to", "find", "the", "timestamp", ":", "return", ":", "dict", "of", "times" ]

[ "def", "get_app_dir", "(", "app", ")", ":", "path", "=", "__app_dirs__", ".", "get", "(", "app", ")", "if", "path", "is", "not", "None", ":", "return", "path", "else", ":", "p", "=", "app", ".", "split", "(", "'.'", ")", "try", ":", "path", "=", "pkg", ".", "resource_filename", "(", "p", "[", "0", "]", ",", "''", ")", "except", "ImportError", "as", "e", ":", "log", ".", "error", "(", "\"Can't import app %s\"", "%", "app", ")", "log", ".", "exception", "(", "e", ")", "path", "=", "''", "if", "len", "(", "p", ")", ">", "1", ":", "path", "=", "os", ".", "path", ".", "join", "(", "path", ",", "*", "p", "[", "1", ":", "]", ")", "__app_dirs__", "[", "app", "]", "=", "path", "return", "path" ]

[ "Get", "an", "app", "s", "directory" ]

[ "def", "generate_timeline", "(", "usnjrnl", ",", "filesystem_content", ")", ":", "journal_content", "=", "defaultdict", "(", "list", ")", "for", "event", "in", "usnjrnl", ":", "journal_content", "[", "event", ".", "inode", "]", ".", "append", "(", "event", ")", "for", "event", "in", "usnjrnl", ":", "try", ":", "dirent", "=", "lookup_dirent", "(", "event", ",", "filesystem_content", ",", "journal_content", ")", "yield", "UsnJrnlEvent", "(", "dirent", ".", "inode", ",", "dirent", ".", "path", ",", "dirent", ".", "size", ",", "dirent", ".", "allocated", ",", "event", ".", "timestamp", ",", "event", ".", "changes", ",", "event", ".", "attributes", ")", "except", "LookupError", "as", "error", ":", "LOGGER", ".", "debug", "(", "error", ")" ]

[ "Aggregates", "the", "data", "collected", "from", "the", "USN", "journal", "and", "the", "filesystem", "content", "." ]

[ "def", "prefixsearch", "(", "self", ",", "prefix", ",", "results", "=", "10", ")", ":", "self", ".", "_check_query", "(", "prefix", ",", "\"Prefix must be specified\"", ")", "query_params", "=", "{", "\"list\"", ":", "\"prefixsearch\"", ",", "\"pssearch\"", ":", "prefix", ",", "\"pslimit\"", ":", "(", "\"max\"", "if", "results", ">", "500", "else", "results", ")", ",", "\"psnamespace\"", ":", "0", ",", "\"psoffset\"", ":", "0", ",", "# parameterize to skip to later in the list?", "}", "raw_results", "=", "self", ".", "wiki_request", "(", "query_params", ")", "self", ".", "_check_error_response", "(", "raw_results", ",", "prefix", ")", "return", "[", "rec", "[", "\"title\"", "]", "for", "rec", "in", "raw_results", "[", "\"query\"", "]", "[", "\"prefixsearch\"", "]", "]" ]

[ "Perform", "a", "prefix", "search", "using", "the", "provided", "prefix", "string" ]

[ "def", "is_response", "(", "cls", ",", "response", ")", ":", "if", "response", ".", "body", ":", "if", "cls", ".", "is_file", "(", "response", ".", "body", ")", ":", "return", "True" ]

[ "Return", "whether", "the", "document", "is", "likely", "to", "be", "a", "Sitemap", "." ]

[ "def", "begin", "(", "self", ",", "transaction", "=", "None", ",", "headers", "=", "None", ",", "*", "*", "keyword_headers", ")", ":", "headers", "=", "utils", ".", "merge_headers", "(", "[", "headers", ",", "keyword_headers", "]", ")", "if", "not", "transaction", ":", "transaction", "=", "utils", ".", "get_uuid", "(", ")", "headers", "[", "HDR_TRANSACTION", "]", "=", "transaction", "self", ".", "send_frame", "(", "CMD_BEGIN", ",", "headers", ")", "return", "transaction" ]

[ "Begin", "a", "transaction", "." ]

[ "def", "evaluate_tokens", "(", "tokens", ")", ":", "if", "isinstance", "(", "tokens", ",", "str", ")", ":", "return", "tokens", "elif", "isinstance", "(", "tokens", ",", "ParseResults", ")", ":", "# evaluate the list portion of the ParseResults", "toklist", ",", "name", ",", "asList", ",", "modal", "=", "tokens", ".", "__getnewargs__", "(", ")", "new_toklist", "=", "[", "evaluate_tokens", "(", "toks", ")", "for", "toks", "in", "toklist", "]", "new_tokens", "=", "ParseResults", "(", "new_toklist", ",", "name", ",", "asList", ",", "modal", ")", "# evaluate the dictionary portion of the ParseResults", "new_tokdict", "=", "{", "}", "for", "name", ",", "occurrences", "in", "tokens", ".", "_ParseResults__tokdict", ".", "items", "(", ")", ":", "new_occurences", "=", "[", "]", "for", "value", ",", "position", "in", "occurrences", ":", "if", "isinstance", "(", "value", ",", "ParseResults", ")", "and", "value", ".", "_ParseResults__toklist", "==", "toklist", ":", "new_value", "=", "new_tokens", "else", ":", "try", ":", "new_value", "=", "new_toklist", "[", "toklist", ".", "index", "(", "value", ")", "]", "except", "ValueError", ":", "complain", "(", "lambda", ":", "CoconutInternalException", "(", "\"inefficient reevaluation of tokens: {} not in {}\"", ".", "format", "(", "value", ",", "toklist", ",", ")", ")", ")", "new_value", "=", "evaluate_tokens", "(", "value", ")", "new_occurences", ".", "append", "(", "_ParseResultsWithOffset", "(", "new_value", ",", "position", ")", ")", "new_tokdict", "[", "name", "]", "=", "occurrences", "new_tokens", ".", "_ParseResults__accumNames", ".", "update", "(", "tokens", ".", "_ParseResults__accumNames", ")", "new_tokens", ".", "_ParseResults__tokdict", ".", "update", "(", "new_tokdict", ")", "return", "new_tokens", "elif", "isinstance", "(", "tokens", ",", "ComputationNode", ")", ":", "return", "tokens", ".", "evaluate", "(", ")", "elif", "isinstance", "(", "tokens", ",", "(", "list", ",", "tuple", ")", ")", ":", "return", "[", "evaluate_tokens", "(", "inner_toks", ")", "for", "inner_toks", "in", "tokens", "]", "else", ":", "raise", "CoconutInternalException", "(", "\"invalid computation graph tokens\"", ",", "tokens", ")" ]

[ "Evaluate", "the", "given", "tokens", "in", "the", "computation", "graph", "." ]

[ "def", "_is_mutated", "(", "self", ")", ":", "mutated", "=", "self", ".", "_mutated", "if", "self", ".", "children", "is", "not", "None", ":", "for", "child", "in", "self", ".", "children", ":", "if", "isinstance", "(", "child", ",", "Sequence", ")", "or", "isinstance", "(", "child", ",", "SequenceOf", ")", ":", "mutated", "=", "mutated", "or", "child", ".", "_is_mutated", "(", ")", "return", "mutated" ]

[ ":", "return", ":", "A", "boolean", "-", "if", "the", "sequence", "or", "any", "children", "(", "recursively", ")", "have", "been", "mutated" ]

[ "def", "create", "(", "self", ",", "virtual_interfaces", ")", ":", "data", "=", "{", "'virtual_interfaces'", ":", "virtual_interfaces", "}", "return", "super", "(", "ApiV4VirtualInterface", ",", "self", ")", ".", "post", "(", "'api/v4/virtual-interface/'", ",", "data", ")" ]

[ "Method", "to", "create", "Virtual", "Interfaces" ]

[ "def", "set_metadata_value", "(", "self", ",", "key", ":", "str", ",", "value", ":", "typing", ".", "Any", ")", "->", "None", ":", "self", ".", "_data_item", ".", "set_metadata_value", "(", "key", ",", "value", ")" ]

[ "Set", "the", "metadata", "value", "for", "the", "given", "key", "." ]

[ "def", "getDefaultConfigObj", "(", "taskname", ",", "configObj", ",", "input_dict", "=", "{", "}", ",", "loadOnly", "=", "True", ")", ":", "if", "configObj", "is", "None", ":", "# Start by grabbing the default values without using the GUI", "# This insures that all subsequent use of the configObj includes", "# all parameters and their last saved values", "configObj", "=", "teal", ".", "load", "(", "taskname", ")", "elif", "isinstance", "(", "configObj", ",", "str", ")", ":", "if", "configObj", ".", "lower", "(", ")", ".", "strip", "(", ")", "==", "'defaults'", ":", "# Load task default .cfg file with all default values", "configObj", "=", "teal", ".", "load", "(", "taskname", ",", "defaults", "=", "True", ")", "# define default filename for configObj", "configObj", ".", "filename", "=", "taskname", ".", "lower", "(", ")", "+", "'.cfg'", "else", ":", "# Load user-specified .cfg file with its special default values", "# we need to call 'fileutil.osfn()' to insure all environment", "# variables specified by the user in the configObj filename are", "# expanded to the full path", "configObj", "=", "teal", ".", "load", "(", "fileutil", ".", "osfn", "(", "configObj", ")", ")", "# merge in the user values for this run", "# this, though, does not save the results for use later", "if", "input_dict", "not", "in", "[", "None", ",", "{", "}", "]", ":", "# and configObj not in [None, {}]:", "# check to see whether any input parameters are unexpected.", "# Any unexpected parameters provided on input should be reported and", "# the code should stop", "validateUserPars", "(", "configObj", ",", "input_dict", ")", "# If everything looks good, merge user inputs with configObj and continue", "cfgpars", ".", "mergeConfigObj", "(", "configObj", ",", "input_dict", ")", "# Update the input .cfg file with the updated parameter values", "#configObj.filename = os.path.join(cfgpars.getAppDir(),os.path.basename(configObj.filename))", "#configObj.write()", "if", "not", "loadOnly", ":", "# We want to run the GUI AFTER merging in any parameters", "# specified by the user on the command-line and provided in", "# input_dict", "configObj", "=", "teal", ".", "teal", "(", "configObj", ",", "loadOnly", "=", "False", ")", "return", "configObj" ]

[ "Return", "default", "configObj", "instance", "for", "task", "updated", "with", "user", "-", "specified", "values", "from", "input_dict", "." ]

[ "def", "simple_debug_shell", "(", "globals", ",", "locals", ")", ":", "try", ":", "import", "readline", "except", "ImportError", ":", "pass", "# ignore", "compile_string_fn", "=", "\"<simple_debug_shell input>\"", "while", "True", ":", "try", ":", "s", "=", "raw_input", "(", "\"> \"", ")", "except", "(", "KeyboardInterrupt", ",", "EOFError", ")", ":", "print", "(", "\"breaked debug shell: \"", "+", "sys", ".", "exc_info", "(", ")", "[", "0", "]", ".", "__name__", ")", "break", "if", "s", ".", "strip", "(", ")", "==", "\"\"", ":", "continue", "try", ":", "c", "=", "compile", "(", "s", ",", "compile_string_fn", ",", "\"single\"", ")", "except", "Exception", "as", "e", ":", "print", "(", "\"%s : %s in %r\"", "%", "(", "e", ".", "__class__", ".", "__name__", ",", "str", "(", "e", ")", ",", "s", ")", ")", "else", ":", "set_linecache", "(", "compile_string_fn", ",", "s", ")", "# noinspection PyBroadException", "try", ":", "ret", "=", "eval", "(", "c", ",", "globals", ",", "locals", ")", "except", "(", "KeyboardInterrupt", ",", "SystemExit", ")", ":", "print", "(", "\"debug shell exit: \"", "+", "sys", ".", "exc_info", "(", ")", "[", "0", "]", ".", "__name__", ")", "break", "except", "Exception", ":", "print", "(", "\"Error executing %r\"", "%", "s", ")", "better_exchook", "(", "*", "sys", ".", "exc_info", "(", ")", ",", "autodebugshell", "=", "False", ")", "else", ":", "# noinspection PyBroadException", "try", ":", "if", "ret", "is", "not", "None", ":", "print", "(", "ret", ")", "except", "Exception", ":", "print", "(", "\"Error printing return value of %r\"", "%", "s", ")", "better_exchook", "(", "*", "sys", ".", "exc_info", "(", ")", ",", "autodebugshell", "=", "False", ")" ]

[ ":", "param", "dict", "[", "str", "]", "globals", ":", ":", "param", "dict", "[", "str", "]", "locals", ":", ":", "return", ":", "nothing" ]

[ "def", "df_string", "(", "df", ",", "percentage_columns", "=", "(", ")", ",", "format_map", "=", "None", ",", "*", "*", "kwargs", ")", ":", "formatters_map", "=", "{", "}", "for", "col", ",", "dtype", "in", "df", ".", "dtypes", ".", "iteritems", "(", ")", ":", "if", "col", "in", "percentage_columns", ":", "formatters_map", "[", "col", "]", "=", "'{:,.2f} %'", ".", "format", "elif", "dtype", "==", "'float64'", ":", "formatters_map", "[", "col", "]", "=", "'{:,.2f}'", ".", "format", "if", "format_map", ":", "for", "key", "in", "format_map", ":", "formatters_map", "[", "key", "]", "=", "format_map", "[", "key", "]", "return", "df", ".", "to_string", "(", "formatters", "=", "formatters_map", ",", "*", "*", "kwargs", ")" ]

[ "Return", "a", "nicely", "formatted", "string", "for", "the", "given", "dataframe", "." ]

[ "def", "set_final_value", "(", "self", ",", "description_type", ",", "value", ")", ":", "types", ",", "_", ",", "_", ",", "vbox_values", ",", "extra_config", "=", "self", ".", "get_description", "(", ")", "# find offset to description type", "for", "offset", ",", "t", "in", "enumerate", "(", "types", ")", ":", "if", "t", "==", "description_type", ":", "break", "else", ":", "raise", "Exception", "(", "\"Failed to find type for %s\"", "%", "description_type", ")", "enabled", "=", "[", "True", "]", "*", "len", "(", "types", ")", "vbox_values", "=", "list", "(", "vbox_values", ")", "extra_config", "=", "list", "(", "extra_config", ")", "if", "isinstance", "(", "value", ",", "basestring", ")", ":", "final_value", "=", "value", "elif", "isinstance", "(", "value", ",", "Enum", ")", ":", "final_value", "=", "str", "(", "value", ".", "_value", ")", "elif", "isinstance", "(", "value", ",", "int", ")", ":", "final_value", "=", "str", "(", "value", ")", "else", ":", "raise", "ValueError", "(", "\"Incorrect value type.\"", ")", "vbox_values", "[", "offset", "]", "=", "final_value", "self", ".", "set_final_values", "(", "enabled", ",", "vbox_values", ",", "extra_config", ")" ]

[ "Set", "the", "value", "for", "the", "given", "description", "type", "." ]

[ "def", "get_hosts", "(", "self", ")", ":", "limited_hosts", "=", "{", "}", "if", "self", ".", "limit", "is", "not", "None", ":", "# Find hosts and groups of hosts to include", "for", "include", "in", "self", ".", "limit", "[", "'include'", "]", ":", "# Include whole group", "for", "hostname", "in", "self", ".", "hosts_in_group", "(", "include", ")", ":", "limited_hosts", "[", "hostname", "]", "=", "self", ".", "hosts", "[", "hostname", "]", "# Include individual host", "if", "include", "in", "self", ".", "hosts", ":", "limited_hosts", "[", "include", "]", "=", "self", ".", "hosts", "[", "include", "]", "# Find hosts and groups of hosts to exclude", "for", "exclude", "in", "self", ".", "limit", "[", "\"exclude\"", "]", ":", "# Exclude whole group", "for", "hostname", "in", "self", ".", "hosts_in_group", "(", "exclude", ")", ":", "if", "hostname", "in", "limited_hosts", ":", "limited_hosts", ".", "pop", "(", "hostname", ")", "# Exclude individual host", "if", "exclude", "in", "limited_hosts", ":", "limited_hosts", ".", "pop", "(", "exclude", ")", "return", "limited_hosts", "else", ":", "# Return all hosts", "return", "self", ".", "hosts" ]

[ "Return", "a", "list", "of", "parsed", "hosts", "info", "with", "the", "limit", "applied", "if", "required", "." ]

[ "def", "decrypt", "(", "self", ",", "encrypted", ")", ":", "decoded", "=", "b64decode", "(", "encrypted", ")", "init_vec", "=", "decoded", "[", ":", "AES", ".", "block_size", "]", "cipher", "=", "AES", ".", "new", "(", "self", ".", "_key", ",", "AES", ".", "MODE_CBC", ",", "init_vec", ")", "return", "AESCipher", ".", "unpad", "(", "cipher", ".", "decrypt", "(", "decoded", "[", "AES", ".", "block_size", ":", "]", ")", ")" ]

[ "Base64", "decodes", "the", "data", "and", "then", "decrypts", "using", "AES", ".", ":", "param", "encrypted", ":", ":", "return", ":" ]

[ "def", "on_security_data_node", "(", "self", ",", "node", ")", ":", "sid", "=", "XmlHelper", ".", "get_child_value", "(", "node", ",", "'security'", ")", "farr", "=", "node", ".", "GetElement", "(", "'fieldData'", ")", "dmap", "=", "defaultdict", "(", "list", ")", "for", "i", "in", "range", "(", "farr", ".", "NumValues", ")", ":", "pt", "=", "farr", ".", "GetValue", "(", "i", ")", "[", "dmap", "[", "f", "]", ".", "append", "(", "XmlHelper", ".", "get_child_value", "(", "pt", ",", "f", ",", "allow_missing", "=", "1", ")", ")", "for", "f", "in", "[", "'date'", "]", "+", "self", ".", "fields", "]", "idx", "=", "dmap", ".", "pop", "(", "'date'", ")", "frame", "=", "DataFrame", "(", "dmap", ",", "columns", "=", "self", ".", "fields", ",", "index", "=", "idx", ")", "frame", ".", "index", ".", "name", "=", "'date'", "self", ".", "response", "[", "sid", "]", "=", "frame" ]

[ "process", "a", "securityData", "node", "-", "FIXME", ":", "currently", "not", "handling", "relateDate", "node" ]

[ "def", "OnApply", "(", "self", ",", "event", ")", ":", "# See if we have valid python", "try", ":", "ast", ".", "parse", "(", "self", ".", "macros", ")", "except", ":", "# Grab the traceback and print it for the user", "s", "=", "StringIO", "(", ")", "e", "=", "exc_info", "(", ")", "# usr_tb will more than likely be none because ast throws", "# SytnaxErrorsas occurring outside of the current", "# execution frame", "usr_tb", "=", "get_user_codeframe", "(", "e", "[", "2", "]", ")", "or", "None", "print_exception", "(", "e", "[", "0", "]", ",", "e", "[", "1", "]", ",", "usr_tb", ",", "None", ",", "s", ")", "post_command_event", "(", "self", ".", "parent", ",", "self", ".", "MacroErrorMsg", ",", "err", "=", "s", ".", "getvalue", "(", ")", ")", "success", "=", "False", "else", ":", "self", ".", "result_ctrl", ".", "SetValue", "(", "''", ")", "post_command_event", "(", "self", ".", "parent", ",", "self", ".", "MacroReplaceMsg", ",", "macros", "=", "self", ".", "macros", ")", "post_command_event", "(", "self", ".", "parent", ",", "self", ".", "MacroExecuteMsg", ")", "success", "=", "True", "event", ".", "Skip", "(", ")", "return", "success" ]

[ "Event", "handler", "for", "Apply", "button" ]

[ "def", "json_error_response", "(", "error", ",", "response", ",", "status_code", "=", "400", ")", ":", "msg", "=", "{", "\"error\"", ":", "error", ".", "error", ",", "\"error_description\"", ":", "error", ".", "explanation", "}", "response", ".", "status_code", "=", "status_code", "response", ".", "add_header", "(", "\"Content-Type\"", ",", "\"application/json\"", ")", "response", ".", "body", "=", "json", ".", "dumps", "(", "msg", ")", "return", "response" ]

[ "Formats", "an", "error", "as", "a", "response", "containing", "a", "JSON", "body", "." ]

[ "def", "add_to_query", "(", "self", ",", "query", ")", ":", "self", ".", "handle", "=", "win32pdh", ".", "AddCounter", "(", "query", ",", "self", ".", "path", ")" ]

[ "Add", "the", "current", "path", "to", "the", "query" ]

[ "def", "calc_wtd_exp", "(", "skydir", ",", "ltc", ",", "event_class", ",", "event_types", ",", "egy_bins", ",", "cth_bins", ",", "fn", ",", "nbin", "=", "16", ")", ":", "cnts", "=", "calc_counts_edisp", "(", "skydir", ",", "ltc", ",", "event_class", ",", "event_types", ",", "egy_bins", ",", "cth_bins", ",", "fn", ",", "nbin", "=", "nbin", ")", "flux", "=", "fn", ".", "flux", "(", "egy_bins", "[", ":", "-", "1", "]", ",", "egy_bins", "[", "1", ":", "]", ")", "return", "cnts", "/", "flux", "[", ":", ",", "None", "]" ]

[ "Calculate", "the", "effective", "exposure", "." ]

[ "def", "molmz", "(", "df", ",", "noise", "=", "10000", ")", ":", "d", "=", "(", "(", "df", ".", "values", ">", "noise", ")", "*", "df", ".", "columns", ")", ".", "max", "(", "axis", "=", "1", ")", "return", "Trace", "(", "d", ",", "df", ".", "index", ",", "name", "=", "'molmz'", ")" ]

[ "The", "mz", "of", "the", "molecular", "ion", "." ]

[ "def", "params_dict", "(", "self", ")", ":", "location_code", "=", "'US'", "language_code", "=", "'en'", "if", "len", "(", "self", ".", "location", ")", ":", "location_code", "=", "locationMap", "[", "process", ".", "extractOne", "(", "self", ".", "location", ",", "self", ".", "locations", ")", "[", "0", "]", "]", "if", "len", "(", "self", ".", "language", ")", ":", "language_code", "=", "langMap", "[", "process", ".", "extractOne", "(", "self", ".", "language", ",", "self", ".", "languages", ")", "[", "0", "]", "]", "params", "=", "{", "'hl'", ":", "language_code", ",", "'gl'", ":", "location_code", ",", "'ceid'", ":", "'{}:{}'", ".", "format", "(", "location_code", ",", "language_code", ")", "}", "return", "params" ]

[ "function", "to", "get", "params", "dict", "for", "HTTP", "request" ]

[ "def", "offset_to_window", "(", "self", ",", "off_x", ",", "off_y", ")", ":", "arr_pts", "=", "np", ".", "asarray", "(", "(", "off_x", ",", "off_y", ")", ")", ".", "T", "return", "self", ".", "tform", "[", "'cartesian_to_native'", "]", ".", "to_", "(", "arr_pts", ")", ".", "T", "[", ":", "2", "]" ]

[ "Convert", "data", "offset", "to", "window", "coordinates", "." ]

[ "def", "setModelData", "(", "self", ",", "editor", ",", "model", ",", "index", ")", ":", "try", ":", "data", "=", "editor", ".", "getData", "(", ")", "except", "InvalidInputError", "as", "ex", ":", "logger", ".", "warn", "(", "ex", ")", "else", ":", "# The value is set via the model so that signals are emitted", "logger", ".", "debug", "(", "\"ConfigItemDelegate.setModelData: {}\"", ".", "format", "(", "data", ")", ")", "model", ".", "setData", "(", "index", ",", "data", ",", "Qt", ".", "EditRole", ")" ]

[ "Gets", "data", "from", "the", "editor", "widget", "and", "stores", "it", "in", "the", "specified", "model", "at", "the", "item", "index", ".", "Does", "this", "by", "calling", "getEditorValue", "of", "the", "config", "tree", "item", "at", "the", "index", "." ]

[ "def", "embed_seqdiag_sequence", "(", "self", ")", ":", "test_name", "=", "BuiltIn", "(", ")", ".", "replace_variables", "(", "'${TEST NAME}'", ")", "outputdir", "=", "BuiltIn", "(", ")", ".", "replace_variables", "(", "'${OUTPUTDIR}'", ")", "path", "=", "os", ".", "path", ".", "join", "(", "outputdir", ",", "test_name", "+", "'.seqdiag'", ")", "SeqdiagGenerator", "(", ")", ".", "compile", "(", "path", ",", "self", ".", "_message_sequence", ")" ]

[ "Create", "a", "message", "sequence", "diagram", "png", "file", "to", "output", "folder", "and", "embed", "the", "image", "to", "log", "file", "." ]

[ "def", "_PromptUserForInput", "(", "self", ",", "input_text", ")", ":", "self", ".", "_output_writer", ".", "Write", "(", "'{0:s}: '", ".", "format", "(", "input_text", ")", ")", "return", "self", ".", "_input_reader", ".", "Read", "(", ")" ]

[ "Prompts", "user", "for", "an", "input", "." ]

[ "def", "init_from_datastore", "(", "self", ")", ":", "self", ".", "_data", "=", "{", "}", "client", "=", "self", ".", "_datastore_client", "for", "entity", "in", "client", ".", "query_fetch", "(", "kind", "=", "KIND_CLASSIFICATION_BATCH", ")", ":", "class_batch_id", "=", "entity", ".", "key", ".", "flat_path", "[", "-", "1", "]", "self", ".", "data", "[", "class_batch_id", "]", "=", "dict", "(", "entity", ")" ]

[ "Initializes", "data", "by", "reading", "it", "from", "the", "datastore", "." ]

[ "def", "get_courses_metadata", "(", "self", ")", ":", "# Implemented from template for osid.learning.ActivityForm.get_assets_metadata_template", "metadata", "=", "dict", "(", "self", ".", "_mdata", "[", "'courses'", "]", ")", "metadata", ".", "update", "(", "{", "'existing_courses_values'", ":", "self", ".", "_my_map", "[", "'courseIds'", "]", "}", ")", "return", "Metadata", "(", "*", "*", "metadata", ")" ]

[ "Gets", "the", "metadata", "for", "the", "courses", "." ]

[ "def", "get_global_shelf_fpath", "(", "appname", "=", "'default'", ",", "ensure", "=", "False", ")", ":", "global_cache_dir", "=", "get_global_cache_dir", "(", "appname", ",", "ensure", "=", "ensure", ")", "shelf_fpath", "=", "join", "(", "global_cache_dir", ",", "meta_util_constants", ".", "global_cache_fname", ")", "return", "shelf_fpath" ]

[ "Returns", "the", "filepath", "to", "the", "global", "shelf" ]

[ "def", "cleanlines", "(", "self", ")", ":", "code", "=", "inspect", ".", "getsource", "(", "self", ".", "func", ")", "code", "=", "'\\n'", ".", "join", "(", "code", ".", "split", "(", "'\"\"\"'", ")", "[", ":", ":", "2", "]", ")", "code", "=", "code", ".", "replace", "(", "'modelutils.'", ",", "''", ")", "for", "(", "name", ",", "shortcut", ")", "in", "zip", "(", "self", ".", "collectornames", ",", "self", ".", "collectorshortcuts", ")", ":", "code", "=", "code", ".", "replace", "(", "'%s.'", "%", "shortcut", ",", "'self.%s.'", "%", "name", ")", "code", "=", "self", ".", "remove_linebreaks_within_equations", "(", "code", ")", "lines", "=", "code", ".", "splitlines", "(", ")", "self", ".", "remove_imath_operators", "(", "lines", ")", "lines", "[", "0", "]", "=", "'def %s(self):'", "%", "self", ".", "funcname", "lines", "=", "[", "l", ".", "split", "(", "'#'", ")", "[", "0", "]", "for", "l", "in", "lines", "]", "lines", "=", "[", "l", "for", "l", "in", "lines", "if", "'fastaccess'", "not", "in", "l", "]", "lines", "=", "[", "l", ".", "rstrip", "(", ")", "for", "l", "in", "lines", "if", "l", ".", "rstrip", "(", ")", "]", "return", "Lines", "(", "*", "lines", ")" ]

[ "Cleaned", "code", "lines", "." ]

[ "def", "price_unit", "(", "self", ")", ":", "currency", "=", "self", ".", "currency", "consumption_unit", "=", "self", ".", "consumption_unit", "if", "not", "currency", "or", "not", "consumption_unit", ":", "_LOGGER", ".", "error", "(", "\"Could not find price_unit.\"", ")", "return", "\" \"", "return", "currency", "+", "\"/\"", "+", "consumption_unit" ]

[ "Return", "the", "price", "unit", "." ]

[ "def", "delete_tags", "(", "filesystemid", ",", "tags", ",", "keyid", "=", "None", ",", "key", "=", "None", ",", "profile", "=", "None", ",", "region", "=", "None", ",", "*", "*", "kwargs", ")", ":", "client", "=", "_get_conn", "(", "key", "=", "key", ",", "keyid", "=", "keyid", ",", "profile", "=", "profile", ",", "region", "=", "region", ")", "client", ".", "delete_tags", "(", "FileSystemId", "=", "filesystemid", ",", "Tags", "=", "tags", ")" ]

[ "Deletes", "the", "specified", "tags", "from", "a", "file", "system", "." ]

[ "def", "create_application_configuration", "(", "self", ",", "name", ",", "properties", ",", "description", "=", "None", ")", ":", "if", "not", "hasattr", "(", "self", ",", "'applicationConfigurations'", ")", ":", "raise", "NotImplementedError", "(", ")", "cv", "=", "ApplicationConfiguration", ".", "_props", "(", "name", ",", "properties", ",", "description", ")", "res", "=", "self", ".", "rest_client", ".", "session", ".", "post", "(", "self", ".", "applicationConfigurations", ",", "headers", "=", "{", "'Accept'", ":", "'application/json'", "}", ",", "json", "=", "cv", ")", "_handle_http_errors", "(", "res", ")", "return", "ApplicationConfiguration", "(", "res", ".", "json", "(", ")", ",", "self", ".", "rest_client", ")" ]

[ "Create", "an", "application", "configuration", "." ]

[ "def", "__setUserMinimumSize", "(", "self", ",", "section", ",", "oldSize", ",", "newSize", ")", ":", "if", "self", ".", "isVisible", "(", ")", ":", "self", ".", "_columnMinimums", "[", "section", "]", "=", "newSize" ]

[ "Records", "the", "user", "minimum", "size", "for", "a", "column", ".", ":", "param", "section", "|", "<int", ">", "oldSize", "|", "<int", ">", "newSize", "|", "<int", ">" ]

[ "def", "modflow_sfr_gag_to_instruction_file", "(", "gage_output_file", ",", "ins_file", "=", "None", ",", "parse_filename", "=", "False", ")", ":", "if", "ins_file", "is", "None", ":", "ins_file", "=", "gage_output_file", "+", "'.ins'", "# navigate the file to be sure the header makes sense", "indat", "=", "[", "line", ".", "strip", "(", ")", "for", "line", "in", "open", "(", "gage_output_file", ",", "'r'", ")", ".", "readlines", "(", ")", "]", "header", "=", "[", "i", "for", "i", "in", "indat", "if", "i", ".", "startswith", "(", "'\"'", ")", "]", "# yank out the gage number to identify the observation names", "if", "parse_filename", ":", "gage_num", "=", "os", ".", "path", ".", "basename", "(", "gage_output_file", ")", ".", "split", "(", "'.'", ")", "[", "0", "]", "else", ":", "gage_num", "=", "re", ".", "sub", "(", "\"[^0-9]\"", ",", "\"\"", ",", "indat", "[", "0", "]", ".", "lower", "(", ")", ".", "split", "(", "\"gage no.\"", ")", "[", "-", "1", "]", ".", "strip", "(", ")", ".", "split", "(", ")", "[", "0", "]", ")", "# get the column names", "cols", "=", "[", "i", ".", "lower", "(", ")", "for", "i", "in", "header", "if", "'data'", "in", "i", ".", "lower", "(", ")", "]", "[", "0", "]", ".", "lower", "(", ")", ".", "replace", "(", "'\"'", ",", "''", ")", ".", "replace", "(", "'data:'", ",", "''", ")", ".", "split", "(", ")", "# make sure \"Flow\" is included in the columns", "if", "'flow'", "not", "in", "cols", ":", "raise", "Exception", "(", "'Requested field \"Flow\" not in gage output columns'", ")", "# find which column is for \"Flow\"", "flowidx", "=", "np", ".", "where", "(", "np", ".", "array", "(", "cols", ")", "==", "'flow'", ")", "[", "0", "]", "[", "0", "]", "# write out the instruction file lines", "inslines", "=", "[", "'l1 '", "+", "(", "flowidx", "+", "1", ")", "*", "'w '", "+", "'!g{0}_{1:d}!'", ".", "format", "(", "gage_num", ",", "j", ")", "for", "j", "in", "range", "(", "len", "(", "indat", ")", "-", "len", "(", "header", ")", ")", "]", "inslines", "[", "0", "]", "=", "inslines", "[", "0", "]", ".", "replace", "(", "'l1'", ",", "'l{0:d}'", ".", "format", "(", "len", "(", "header", ")", "+", "1", ")", ")", "# write the instruction file", "with", "open", "(", "ins_file", ",", "'w'", ")", "as", "ofp", ":", "ofp", ".", "write", "(", "'pif ~\\n'", ")", "[", "ofp", ".", "write", "(", "'{0}\\n'", ".", "format", "(", "line", ")", ")", "for", "line", "in", "inslines", "]", "df", "=", "_try_run_inschek", "(", "ins_file", ",", "gage_output_file", ")", "if", "df", "is", "not", "None", ":", "return", "df", ",", "ins_file", ",", "gage_output_file", "else", ":", "print", "(", "\"Inschek didn't run so nothing returned\"", ")", "return", "None" ]

[ "writes", "an", "instruction", "file", "for", "an", "SFR", "gage", "output", "file", "to", "read", "Flow", "only", "at", "all", "times" ]

[ "def", "write_job", "(", "self", ",", "fh", ")", ":", "if", "isinstance", "(", "self", ".", "job", "(", ")", ",", "CondorDAGManJob", ")", ":", "# create an external subdag from this dag", "fh", ".", "write", "(", "' '", ".", "join", "(", "[", "'SUBDAG EXTERNAL'", ",", "self", ".", "__name", ",", "self", ".", "__job", ".", "get_sub_file", "(", ")", "]", ")", ")", "if", "self", ".", "job", "(", ")", ".", "get_dag_directory", "(", ")", ":", "fh", ".", "write", "(", "' DIR '", "+", "self", ".", "job", "(", ")", ".", "get_dag_directory", "(", ")", ")", "else", ":", "# write a regular condor job", "fh", ".", "write", "(", "'JOB '", "+", "self", ".", "__name", "+", "' '", "+", "self", ".", "__job", ".", "get_sub_file", "(", ")", ")", "fh", ".", "write", "(", "'\\n'", ")", "fh", ".", "write", "(", "'RETRY '", "+", "self", ".", "__name", "+", "' '", "+", "str", "(", "self", ".", "__retry", ")", "+", "'\\n'", ")" ]

[ "Write", "the", "DAG", "entry", "for", "this", "node", "s", "job", "to", "the", "DAG", "file", "descriptor", "." ]

[ "def", "find_range_in_section_list", "(", "start", ",", "end", ",", "section_list", ")", ":", "ind", "=", "find_range_ix_in_section_list", "(", "start", ",", "end", ",", "section_list", ")", "return", "section_list", "[", "ind", "[", "0", "]", ":", "ind", "[", "1", "]", "]" ]

[ "Returns", "all", "sections", "belonging", "to", "the", "given", "range", "." ]

[ "def", "set_swimlane", "(", "self", ",", "value", ")", ":", "if", "value", "==", "[", "{", "\"$type\"", ":", "\"Core.Models.Utilities.UserGroupSelection, Core\"", "}", "]", ":", "value", "=", "[", "]", "return", "super", "(", "UserGroupField", ",", "self", ")", ".", "set_swimlane", "(", "value", ")" ]

[ "Workaround", "for", "reports", "returning", "an", "empty", "usergroup", "field", "as", "a", "single", "element", "list", "with", "no", "id", "/", "name" ]

[ "def", "check_overlap", "(", "a", ",", "b", ")", ":", "if", "a", ".", "isAnalytic", "or", "b", ".", "isAnalytic", ":", "#then it's defined everywhere", "result", "=", "'full'", "else", ":", "#get the wavelength arrays", "waves", "=", "list", "(", ")", "for", "x", "in", "(", "a", ",", "b", ")", ":", "if", "hasattr", "(", "x", ",", "'throughput'", ")", ":", "wv", "=", "x", ".", "wave", "[", "np", ".", "where", "(", "x", ".", "throughput", "!=", "0", ")", "]", "elif", "hasattr", "(", "x", ",", "'flux'", ")", ":", "wv", "=", "x", ".", "wave", "else", ":", "raise", "AttributeError", "(", "\"neither flux nor throughput in %s\"", "%", "x", ")", "waves", ".", "append", "(", "wv", ")", "#get the endpoints", "a1", ",", "a2", "=", "waves", "[", "0", "]", ".", "min", "(", ")", ",", "waves", "[", "0", "]", ".", "max", "(", ")", "b1", ",", "b2", "=", "waves", "[", "1", "]", ".", "min", "(", ")", ",", "waves", "[", "1", "]", ".", "max", "(", ")", "#do the comparison", "if", "(", "a1", ">=", "b1", "and", "a2", "<=", "b2", ")", ":", "result", "=", "'full'", "elif", "(", "a2", "<", "b1", ")", "or", "(", "b2", "<", "a1", ")", ":", "result", "=", "'none'", "else", ":", "result", "=", "'partial'", "return", "result" ]

[ "Check", "for", "wavelength", "overlap", "between", "two", "spectra", "." ]

[ "def", "Write", "(", "self", ",", "outpath", ")", ":", "out", "=", "zipfile", ".", "ZipFile", "(", "outpath", ",", "mode", "=", "\"w\"", ",", "compression", "=", "zipfile", ".", "ZIP_DEFLATED", ")", "for", "filename", ",", "func", "in", "[", "(", "'agency.txt'", ",", "self", ".", "WriteAgency", ")", ",", "(", "'calendar.txt'", ",", "self", ".", "WriteCalendar", ")", ",", "(", "'calendar_dates.txt'", ",", "self", ".", "WriteCalendarDates", ")", ",", "(", "'routes.txt'", ",", "self", ".", "WriteRoutes", ")", ",", "(", "'trips.txt'", ",", "self", ".", "WriteTrips", ")", ",", "(", "'stops.txt'", ",", "self", ".", "WriteStations", ")", ",", "(", "'stop_times.txt'", ",", "self", ".", "WriteStopTimes", ")", "]", ":", "s", "=", "cStringIO", ".", "StringIO", "(", ")", "func", "(", "s", ")", "out", ".", "writestr", "(", "filename", ",", "s", ".", "getvalue", "(", ")", ")", "out", ".", "close", "(", ")" ]

[ "Writes", "a", ".", "zip", "file", "in", "Google", "Transit", "format", "." ]

[ "def", "get_param_values", "(", "self_", ",", "onlychanged", "=", "False", ")", ":", "self_or_cls", "=", "self_", ".", "self_or_cls", "# CEB: we'd actually like to know whether a value has been", "# explicitly set on the instance, but I'm not sure that's easy", "# (would need to distinguish instantiation of default from", "# user setting of value).", "vals", "=", "[", "]", "for", "name", ",", "val", "in", "self_or_cls", ".", "param", ".", "objects", "(", "'existing'", ")", ".", "items", "(", ")", ":", "value", "=", "self_or_cls", ".", "param", ".", "get_value_generator", "(", "name", ")", "# (this is pointless for cls)", "if", "not", "onlychanged", "or", "not", "all_equal", "(", "value", ",", "val", ".", "default", ")", ":", "vals", ".", "append", "(", "(", "name", ",", "value", ")", ")", "vals", ".", "sort", "(", "key", "=", "itemgetter", "(", "0", ")", ")", "return", "vals" ]

[ "Return", "a", "list", "of", "name", "value", "pairs", "for", "all", "Parameters", "of", "this", "object", "." ]

[ "def", "_extract_clublog_header", "(", "self", ",", "cty_xml_filename", ")", ":", "cty_header", "=", "{", "}", "try", ":", "with", "open", "(", "cty_xml_filename", ",", "\"r\"", ")", "as", "cty", ":", "raw_header", "=", "cty", ".", "readline", "(", ")", "cty_date", "=", "re", ".", "search", "(", "\"date='.+'\"", ",", "raw_header", ")", "if", "cty_date", ":", "cty_date", "=", "cty_date", ".", "group", "(", "0", ")", ".", "replace", "(", "\"date=\"", ",", "\"\"", ")", ".", "replace", "(", "\"'\"", ",", "\"\"", ")", "cty_date", "=", "datetime", ".", "strptime", "(", "cty_date", "[", ":", "19", "]", ",", "'%Y-%m-%dT%H:%M:%S'", ")", "cty_date", ".", "replace", "(", "tzinfo", "=", "UTC", ")", "cty_header", "[", "\"Date\"", "]", "=", "cty_date", "cty_ns", "=", "re", ".", "search", "(", "\"xmlns='.+[']\"", ",", "raw_header", ")", "if", "cty_ns", ":", "cty_ns", "=", "cty_ns", ".", "group", "(", "0", ")", ".", "replace", "(", "\"xmlns=\"", ",", "\"\"", ")", ".", "replace", "(", "\"'\"", ",", "\"\"", ")", "cty_header", "[", "'NameSpace'", "]", "=", "cty_ns", "if", "len", "(", "cty_header", ")", "==", "2", ":", "self", ".", "_logger", ".", "debug", "(", "\"Header successfully retrieved from CTY File\"", ")", "elif", "len", "(", "cty_header", ")", "<", "2", ":", "self", ".", "_logger", ".", "warning", "(", "\"Header could only be partically retrieved from CTY File\"", ")", "self", ".", "_logger", ".", "warning", "(", "\"Content of Header: \"", ")", "for", "key", "in", "cty_header", ":", "self", ".", "_logger", ".", "warning", "(", "str", "(", "key", ")", "+", "\": \"", "+", "str", "(", "cty_header", "[", "key", "]", ")", ")", "return", "cty_header", "except", "Exception", "as", "e", ":", "self", ".", "_logger", ".", "error", "(", "\"Clublog CTY File could not be opened / modified\"", ")", "self", ".", "_logger", ".", "error", "(", "\"Error Message: \"", "+", "str", "(", "e", ")", ")", "return" ]

[ "Extract", "the", "header", "of", "the", "Clublog", "XML", "File" ]

[ "def", "filter_arrange_nodes", "(", "nodes", ":", "List", "[", "ast", ".", "stmt", "]", ",", "max_line_number", ":", "int", ")", "->", "List", "[", "ast", ".", "stmt", "]", ":", "return", "[", "node", "for", "node", "in", "nodes", "if", "node", ".", "lineno", "<", "max_line_number", "and", "not", "isinstance", "(", "node", ",", "ast", ".", "Pass", ")", "and", "not", "(", "isinstance", "(", "node", ",", "ast", ".", "Expr", ")", "and", "isinstance", "(", "node", ".", "value", ",", "ast", ".", "Str", ")", ")", "]" ]

[ "Finds", "all", "nodes", "that", "are", "before", "the", "max_line_number", "and", "are", "not", "docstrings", "or", "pass", "." ]

[ "def", "share_vm_image", "(", "self", ",", "vm_image_name", ",", "permission", ")", ":", "_validate_not_none", "(", "'vm_image_name'", ",", "vm_image_name", ")", "_validate_not_none", "(", "'permission'", ",", "permission", ")", "path", "=", "self", ".", "_get_sharing_path_using_vm_image_name", "(", "vm_image_name", ")", "query", "=", "'&permission='", "+", "permission", "path", "=", "path", "+", "'?'", "+", "query", ".", "lstrip", "(", "'&'", ")", "return", "self", ".", "_perform_put", "(", "path", ",", "None", ",", "as_async", "=", "True", ",", "x_ms_version", "=", "'2015-04-01'", ")" ]

[ "Share", "an", "already", "replicated", "OS", "image", ".", "This", "operation", "is", "only", "for", "publishers", ".", "You", "have", "to", "be", "registered", "as", "image", "publisher", "with", "Windows", "Azure", "to", "be", "able", "to", "call", "this", "." ]

[ "def", "with_transaction", "(", "self", ",", "callback", ",", "read_concern", "=", "None", ",", "write_concern", "=", "None", ",", "read_preference", "=", "None", ")", ":", "start_time", "=", "monotonic", ".", "time", "(", ")", "while", "True", ":", "self", ".", "start_transaction", "(", "read_concern", ",", "write_concern", ",", "read_preference", ")", "try", ":", "ret", "=", "callback", "(", "self", ")", "except", "Exception", "as", "exc", ":", "if", "self", ".", "_in_transaction", ":", "self", ".", "abort_transaction", "(", ")", "if", "(", "isinstance", "(", "exc", ",", "PyMongoError", ")", "and", "exc", ".", "has_error_label", "(", "\"TransientTransactionError\"", ")", "and", "_within_time_limit", "(", "start_time", ")", ")", ":", "# Retry the entire transaction.", "continue", "raise", "if", "self", ".", "_transaction", ".", "state", "in", "(", "_TxnState", ".", "NONE", ",", "_TxnState", ".", "COMMITTED", ",", "_TxnState", ".", "ABORTED", ")", ":", "# Assume callback intentionally ended the transaction.", "return", "ret", "while", "True", ":", "try", ":", "self", ".", "commit_transaction", "(", ")", "except", "PyMongoError", "as", "exc", ":", "if", "(", "exc", ".", "has_error_label", "(", "\"UnknownTransactionCommitResult\"", ")", "and", "_within_time_limit", "(", "start_time", ")", ")", ":", "# Retry the commit.", "continue", "if", "(", "exc", ".", "has_error_label", "(", "\"TransientTransactionError\"", ")", "and", "_within_time_limit", "(", "start_time", ")", ")", ":", "# Retry the entire transaction.", "break", "raise", "# Commit succeeded.", "return", "ret" ]

[ "Execute", "a", "callback", "in", "a", "transaction", "." ]

[ "def", "point_in_triangle", "(", "p", ",", "v1", ",", "v2", ",", "v3", ")", ":", "def", "_test", "(", "p1", ",", "p2", ",", "p3", ")", ":", "return", "(", "p1", "[", "0", "]", "-", "p3", "[", "0", "]", ")", "*", "(", "p2", "[", "1", "]", "-", "p3", "[", "1", "]", ")", "-", "(", "p2", "[", "0", "]", "-", "p3", "[", "0", "]", ")", "*", "(", "p1", "[", "1", "]", "-", "p3", "[", "1", "]", ")", "b1", "=", "_test", "(", "p", ",", "v1", ",", "v2", ")", "<", "0.0", "b2", "=", "_test", "(", "p", ",", "v2", ",", "v3", ")", "<", "0.0", "b3", "=", "_test", "(", "p", ",", "v3", ",", "v1", ")", "<", "0.0", "return", "(", "b1", "==", "b2", ")", "and", "(", "b2", "==", "b3", ")" ]

[ "Checks", "whether", "a", "point", "is", "within", "the", "given", "triangle" ]

[ "def", "WriteSignedBinaryBlobs", "(", "binary_urn", ",", "blobs", ",", "token", "=", "None", ")", ":", "if", "_ShouldUseLegacyDatastore", "(", ")", ":", "aff4", ".", "FACTORY", ".", "Delete", "(", "binary_urn", ",", "token", "=", "token", ")", "with", "data_store", ".", "DB", ".", "GetMutationPool", "(", ")", "as", "mutation_pool", ":", "with", "aff4", ".", "FACTORY", ".", "Create", "(", "binary_urn", ",", "collects", ".", "GRRSignedBlob", ",", "mode", "=", "\"w\"", ",", "mutation_pool", "=", "mutation_pool", ",", "token", "=", "token", ")", "as", "fd", ":", "for", "blob", "in", "blobs", ":", "fd", ".", "Add", "(", "blob", ",", "mutation_pool", "=", "mutation_pool", ")", "if", "data_store", ".", "RelationalDBEnabled", "(", ")", ":", "blob_references", "=", "rdf_objects", ".", "BlobReferences", "(", ")", "current_offset", "=", "0", "for", "blob", "in", "blobs", ":", "blob_id", "=", "data_store", ".", "BLOBS", ".", "WriteBlobWithUnknownHash", "(", "blob", ".", "SerializeToString", "(", ")", ")", "blob_references", ".", "items", ".", "Append", "(", "rdf_objects", ".", "BlobReference", "(", "offset", "=", "current_offset", ",", "size", "=", "len", "(", "blob", ".", "data", ")", ",", "blob_id", "=", "blob_id", ")", ")", "current_offset", "+=", "len", "(", "blob", ".", "data", ")", "data_store", ".", "REL_DB", ".", "WriteSignedBinaryReferences", "(", "_SignedBinaryIDFromURN", "(", "binary_urn", ")", ",", "blob_references", ")" ]

[ "Saves", "signed", "blobs", "to", "the", "datastore", "." ]

[ "def", "vicinity", "(", "self", ")", ":", "if", "self", ".", "_vicinity", "==", "''", "and", "self", ".", "details", "!=", "None", "and", "'vicinity'", "in", "self", ".", "details", ":", "self", ".", "_vicinity", "=", "self", ".", "details", "[", "'vicinity'", "]", "return", "self", ".", "_vicinity" ]

[ "Returns", "a", "feature", "name", "of", "a", "nearby", "location", "." ]

[ "def", "critical", "(", "self", ",", "event", "=", "None", ",", "*", "args", ",", "*", "*", "kw", ")", ":", "if", "not", "self", ".", "_logger", ".", "isEnabledFor", "(", "logging", ".", "CRITICAL", ")", ":", "return", "kw", "=", "self", ".", "_add_base_info", "(", "kw", ")", "kw", "[", "'level'", "]", "=", "\"critical\"", "return", "self", ".", "_proxy_to_logger", "(", "'critical'", ",", "event", ",", "*", "args", ",", "*", "*", "kw", ")" ]

[ "Process", "event", "and", "call", ":", "meth", ":", "logging", ".", "Logger", ".", "critical", "with", "the", "result", "." ]

[ "def", "summarize", "(", "reintegrate", "=", "True", ",", "dist_tolerance", "=", "3", ",", "qranges", "=", "None", ",", "samples", "=", "None", ",", "raw", "=", "False", ",", "late_radavg", "=", "True", ",", "graph_ncols", "=", "3", ",", "std_multiplier", "=", "3", ",", "graph_extension", "=", "'png'", ",", "graph_dpi", "=", "80", ",", "correlmatrix_colormap", "=", "'coolwarm'", ",", "image_colormap", "=", "'viridis'", ",", "correlmatrix_logarithmic", "=", "True", ",", "cormaptest", "=", "True", ")", ":", "if", "qranges", "is", "None", ":", "qranges", "=", "{", "}", "ip", "=", "get_ipython", "(", ")", "data2d", "=", "{", "}", "data1d", "=", "{", "}", "headers_tosave", "=", "{", "}", "rowavg", "=", "{", "}", "if", "raw", ":", "writemarkdown", "(", "'# Summarizing RAW images.'", ")", "headers", "=", "ip", ".", "user_ns", "[", "'_headers'", "]", "[", "'raw'", "]", "rawpart", "=", "'_raw'", "# this will be added in the filenames saved", "else", ":", "writemarkdown", "(", "'# Summarizing CORRECTED images.'", ")", "headers", "=", "ip", ".", "user_ns", "[", "'_headers'", "]", "[", "'processed'", "]", "rawpart", "=", "''", "# nothing will be added in the filenames saved", "if", "samples", "is", "None", ":", "samples", "=", "sorted", "(", "ip", ".", "user_ns", "[", "'allsamplenames'", "]", ")", "for", "samplename", "in", "samples", ":", "writemarkdown", "(", "'## '", "+", "samplename", ")", "headers_sample", "=", "[", "h", "for", "h", "in", "headers", "if", "h", ".", "title", "==", "samplename", "]", "data2d", "[", "samplename", "]", "=", "{", "}", "rowavg", "[", "samplename", "]", "=", "{", "}", "data1d", "[", "samplename", "]", "=", "{", "}", "headers_tosave", "[", "samplename", "]", "=", "{", "}", "dists", "=", "get_different_distances", "(", "[", "h", "for", "h", "in", "headers", "if", "h", ".", "title", "==", "samplename", "]", ",", "dist_tolerance", ")", "if", "not", "dists", ":", "writemarkdown", "(", "'No measurements from sample, skipping.'", ")", "continue", "fig_2d", "=", "plt", ".", "figure", "(", ")", "fig_curves", "=", "plt", ".", "figure", "(", ")", "fig_correlmatrices", "=", "plt", ".", "figure", "(", ")", "distaxes", "=", "{", "}", "correlmatrixaxes", "=", "{", "}", "ncols", "=", "min", "(", "len", "(", "dists", ")", ",", "graph_ncols", ")", "nrows", "=", "int", "(", "np", ".", "ceil", "(", "len", "(", "dists", ")", "/", "ncols", ")", ")", "onedimaxes", "=", "fig_curves", ".", "add_axes", "(", "(", "0.1", ",", "0.3", ",", "0.8", ",", "0.5", ")", ")", "onedimstdaxes", "=", "fig_curves", ".", "add_axes", "(", "(", "0.1", ",", "0.1", ",", "0.8", ",", "0.2", ")", ")", "for", "distidx", ",", "dist", "in", "enumerate", "(", "dists", ")", ":", "writemarkdown", "(", "\"### Distance \"", "+", "str", "(", "dist", ")", "+", "\" mm\"", ")", "headers_narrowed", "=", "[", "h", "for", "h", "in", "headers_sample", "if", "abs", "(", "float", "(", "h", ".", "distance", ")", "-", "dist", ")", "<", "dist_tolerance", "]", "distaxes", "[", "dist", "]", "=", "fig_2d", ".", "add_subplot", "(", "nrows", ",", "ncols", ",", "distidx", "+", "1", ")", "correlmatrixaxes", "[", "dist", "]", "=", "fig_correlmatrices", ".", "add_subplot", "(", "nrows", ",", "ncols", ",", "distidx", "+", "1", ")", "# determine the q-range to be used from the qranges argument.", "try", ":", "distkey_min", "=", "min", "(", "[", "np", ".", "abs", "(", "k", "-", "dist", ")", "for", "k", "in", "qranges", "if", "np", ".", "abs", "(", "k", "-", "dist", ")", "<", "dist_tolerance", "]", ")", "except", "ValueError", ":", "# no matching key in qranges dict", "qrange", "=", "None", "# request auto-determination of q-range", "else", ":", "distkey", "=", "[", "k", "for", "k", "in", "qranges", "if", "np", ".", "abs", "(", "k", "-", "dist", ")", "==", "distkey_min", "]", "[", "0", "]", "qrange", "=", "qranges", "[", "distkey", "]", "(", "data1d", "[", "samplename", "]", "[", "dist", "]", ",", "data2d", "[", "samplename", "]", "[", "dist", "]", ",", "headers_tosave", "[", "samplename", "]", "[", "dist", "]", ")", "=", "_collect_data_for_summarization", "(", "headers_narrowed", ",", "raw", ",", "reintegrate", ",", "qrange", ")", "badfsns", ",", "badfsns_datcmp", ",", "tab", ",", "rowavg", "[", "samplename", "]", "[", "dist", "]", "=", "_stabilityassessment", "(", "headers_tosave", "[", "samplename", "]", "[", "dist", "]", ",", "data1d", "[", "samplename", "]", "[", "dist", "]", ",", "dist", ",", "fig_correlmatrices", ",", "correlmatrixaxes", "[", "dist", "]", ",", "std_multiplier", ",", "correlmatrix_colormap", ",", "os", ".", "path", ".", "join", "(", "ip", ".", "user_ns", "[", "'saveto_dir'", "]", ",", "'correlmatrix_%s_%s'", "%", "(", "samplename", ",", "(", "'%.2f'", "%", "dist", ")", ".", "replace", "(", "'.'", ",", "'_'", ")", ")", "+", "rawpart", "+", "'.npz'", ")", ",", "logarithmic_correlmatrix", "=", "correlmatrix_logarithmic", ",", "cormaptest", "=", "cormaptest", ")", "if", "'badfsns'", "not", "in", "ip", ".", "user_ns", ":", "ip", ".", "user_ns", "[", "'badfsns'", "]", "=", "{", "}", "elif", "'badfsns_datcmp'", "not", "in", "ip", ".", "user_ns", ":", "ip", ".", "user_ns", "[", "'badfsns_datcmp'", "]", "=", "{", "}", "ip", ".", "user_ns", "[", "'badfsns'", "]", "=", "set", "(", "ip", ".", "user_ns", "[", "'badfsns'", "]", ")", ".", "union", "(", "badfsns", ")", "ip", ".", "user_ns", "[", "'badfsns_datcmp'", "]", "=", "set", "(", "ip", ".", "user_ns", "[", "'badfsns_datcmp'", "]", ")", ".", "union", "(", "badfsns_datcmp", ")", "display", "(", "tab", ")", "# Plot the image", "try", ":", "data2d", "[", "samplename", "]", "[", "dist", "]", ".", "imshow", "(", "axes", "=", "distaxes", "[", "dist", "]", ",", "show_crosshair", "=", "False", ",", "norm", "=", "matplotlib", ".", "colors", ".", "LogNorm", "(", ")", ",", "cmap", "=", "matplotlib", ".", "cm", ".", "get_cmap", "(", "image_colormap", ")", ")", "except", "ValueError", ":", "print", "(", "'Error plotting 2D image for sample %s, distance %.2f'", "%", "(", "samplename", ",", "dist", ")", ")", "distaxes", "[", "dist", "]", ".", "set_xlabel", "(", "'q ('", "+", "qunit", "(", ")", "+", "')'", ")", "distaxes", "[", "dist", "]", ".", "set_ylabel", "(", "'q ('", "+", "qunit", "(", ")", "+", "')'", ")", "distaxes", "[", "dist", "]", ".", "set_title", "(", "'%.2f mm (%d curve%s)'", "%", "(", "dist", ",", "len", "(", "headers_tosave", "[", "samplename", "]", "[", "dist", "]", ")", ",", "[", "''", ",", "'s'", "]", "[", "len", "(", "headers_tosave", "[", "samplename", "]", "[", "dist", "]", ")", ">", "1", "]", ")", ")", "# Plot the curves", "Istd", "=", "np", ".", "stack", "(", "[", "c", ".", "Intensity", "for", "c", "in", "data1d", "[", "samplename", "]", "[", "dist", "]", "]", ",", "axis", "=", "1", ")", "for", "c", ",", "h", "in", "zip", "(", "data1d", "[", "samplename", "]", "[", "dist", "]", ",", "headers_tosave", "[", "samplename", "]", "[", "dist", "]", ")", ":", "color", "=", "'green'", "if", "h", ".", "fsn", "in", "badfsns_datcmp", ":", "color", "=", "'magenta'", "if", "h", ".", "fsn", "in", "badfsns", ":", "color", "=", "'red'", "c", ".", "loglog", "(", "axes", "=", "onedimaxes", ",", "color", "=", "color", ")", "if", "Istd", ".", "shape", "[", "1", "]", ">", "1", ":", "onedimstdaxes", ".", "loglog", "(", "data1d", "[", "samplename", "]", "[", "dist", "]", "[", "0", "]", ".", "q", ",", "Istd", ".", "std", "(", "axis", "=", "1", ")", "/", "Istd", ".", "mean", "(", "axis", "=", "1", ")", "*", "100", ",", "'b-'", ")", "if", "not", "late_radavg", ":", "data1d", "[", "samplename", "]", "[", "dist", "]", "=", "Curve", ".", "average", "(", "*", "data1d", "[", "samplename", "]", "[", "dist", "]", ")", "else", ":", "data1d", "[", "samplename", "]", "[", "dist", "]", "=", "(", "data2d", "[", "samplename", "]", "[", "dist", "]", ".", "radial_average", "(", "qrange", ",", "errorpropagation", "=", "3", ",", "abscissa_errorpropagation", "=", "3", ",", "raw_result", "=", "False", ")", ")", "data1d", "[", "samplename", "]", "[", "dist", "]", ".", "loglog", "(", "label", "=", "'Average'", ",", "lw", "=", "2", ",", "color", "=", "'k'", ",", "axes", "=", "onedimaxes", ")", "##Saving image, headers, mask and curve", "# data2d[samplename][dist].write(", "# os.path.join(ip.user_ns['saveto_dir'],", "# samplename + '_'+(", "# '%.2f' % dist).replace('.', '_') +", "# rawpart + '.npz'), plugin='CREDO Reduced')", "# data2d[samplename][dist].header.write(", "# os.path.join(ip.user_ns['saveto_dir'],", "### samplename + '_'+(", "# '%.2f' % dist).replace('.', '_') +", "# rawpart +'.log'), plugin='CREDO Reduced')", "# data2d[samplename][dist].mask.write_to_mat(", "# os.path.join(ip.user_ns['saveto_dir'],", "# data2d[samplename][dist].mask.maskid+'.mat'))", "data1d", "[", "samplename", "]", "[", "dist", "]", ".", "save", "(", "os", ".", "path", ".", "join", "(", "ip", ".", "user_ns", "[", "'saveto_dir'", "]", ",", "samplename", "+", "'_'", "+", "(", "'%.2f'", "%", "dist", ")", ".", "replace", "(", "'.'", ",", "'_'", ")", "+", "rawpart", "+", "'.txt'", ")", ")", "# Report on qrange and flux", "q_", "=", "data1d", "[", "samplename", "]", "[", "dist", "]", ".", "q", "qmin", "=", "q_", "[", "q_", ">", "0", "]", ".", "min", "(", ")", "writemarkdown", "(", "'#### Q-range & flux'", ")", "writemarkdown", "(", "'- $q_{min}$: '", "+", "print_abscissavalue", "(", "qmin", ",", "headers_tosave", "[", "samplename", "]", "[", "dist", "]", "[", "0", "]", ".", "wavelength", ",", "dist", ")", ")", "writemarkdown", "(", "'- $q_{max}$: '", "+", "print_abscissavalue", "(", "data1d", "[", "samplename", "]", "[", "dist", "]", ".", "q", ".", "max", "(", ")", ",", "headers_tosave", "[", "samplename", "]", "[", "dist", "]", "[", "0", "]", ".", "wavelength", ",", "dist", ")", ")", "writemarkdown", "(", "'- Number of $q$ points: '", "+", "str", "(", "len", "(", "data1d", "[", "samplename", "]", "[", "dist", "]", ")", ")", ")", "meastime", "=", "sum", "(", "[", "h", ".", "exposuretime", "for", "h", "in", "headers_tosave", "[", "samplename", "]", "[", "dist", "]", "]", ")", "writemarkdown", "(", "\"- from %d exposures, total exposure time %.0f sec <=> %.2f hr\"", "%", "(", "len", "(", "headers_tosave", "[", "samplename", "]", "[", "dist", "]", ")", ",", "meastime", ",", "meastime", "/", "3600.", ")", ")", "try", ":", "flux", "=", "[", "h", ".", "flux", "for", "h", "in", "headers_tosave", "[", "samplename", "]", "[", "dist", "]", "]", "flux", "=", "ErrorValue", "(", "np", ".", "mean", "(", "flux", ")", ",", "np", ".", "std", "(", "flux", ")", ")", "writemarkdown", "(", "\"- beam flux (photon/sec): %s\"", "%", "flux", ")", "except", "KeyError", ":", "writemarkdown", "(", "\"- *No information on beam flux: dealing with raw data.*\"", ")", "onedimaxes", ".", "set_xlabel", "(", "''", ")", "onedimaxes", ".", "set_ylabel", "(", "'$d\\\\Sigma/d\\\\Omega$ (cm$^{-1}$ sr$^{-1}$)'", ")", "# plt.legend(loc='best')", "onedimaxes", ".", "grid", "(", "True", ",", "which", "=", "'both'", ")", "onedimaxes", ".", "axis", "(", "'tight'", ")", "onedimaxes", ".", "set_title", "(", "samplename", ")", "onedimstdaxes", ".", "set_xlabel", "(", "'q ('", "+", "qunit", "(", ")", "+", "')'", ")", "onedimstdaxes", ".", "set_ylabel", "(", "'Rel.std.dev. of intensity (%)'", ")", "onedimstdaxes", ".", "grid", "(", "True", ",", "which", "=", "'both'", ")", "onedimstdaxes", ".", "set_xlim", "(", "*", "onedimaxes", ".", "get_xlim", "(", ")", ")", "onedimstdaxes", ".", "set_xscale", "(", "onedimaxes", ".", "get_xscale", "(", ")", ")", "putlogo", "(", "fig_curves", ")", "putlogo", "(", "fig_2d", ")", "fig_2d", ".", "tight_layout", "(", ")", "fig_correlmatrices", ".", "suptitle", "(", "samplename", ")", "fig_correlmatrices", ".", "tight_layout", "(", ")", "fig_2d", ".", "savefig", "(", "os", ".", "path", ".", "join", "(", "ip", ".", "user_ns", "[", "'auximages_dir'", "]", ",", "'averaging2D_'", "+", "samplename", "+", "rawpart", "+", "'.'", "+", "graph_extension", ")", ",", "dpi", "=", "graph_dpi", ")", "fig_curves", ".", "savefig", "(", "os", ".", "path", ".", "join", "(", "ip", ".", "user_ns", "[", "'auximages_dir'", "]", ",", "'averaging1D_'", "+", "samplename", "+", "rawpart", "+", "'.'", "+", "graph_extension", ")", ",", "dpi", "=", "graph_dpi", ")", "putlogo", "(", "fig_correlmatrices", ")", "fig_correlmatrices", ".", "savefig", "(", "os", ".", "path", ".", "join", "(", "ip", ".", "user_ns", "[", "'auximages_dir'", "]", ",", "'correlation_'", "+", "samplename", "+", "rawpart", "+", "'.'", "+", "graph_extension", ")", ",", "dpi", "=", "graph_dpi", ")", "writemarkdown", "(", "\"### Collected images from all distances\"", ")", "plt", ".", "show", "(", ")", "writemarkdown", "(", "\"Updated badfsns list:\"", ")", "writemarkdown", "(", "'['", "+", "', '", ".", "join", "(", "str", "(", "f", ")", "for", "f", "in", "ip", ".", "user_ns", "[", "'badfsns'", "]", ")", "+", "']'", ")", "writemarkdown", "(", "\"Updated badfsns list using datcmp:\"", ")", "writemarkdown", "(", "'['", "+", "', '", ".", "join", "(", "str", "(", "f", ")", "for", "f", "in", "ip", ".", "user_ns", "[", "'badfsns_datcmp'", "]", ")", "+", "']'", ")", "ip", ".", "user_ns", "[", "'_data1d'", "]", "=", "data1d", "ip", ".", "user_ns", "[", "'_data2d'", "]", "=", "data2d", "ip", ".", "user_ns", "[", "'_headers_sample'", "]", "=", "headers_tosave", "ip", ".", "user_ns", "[", "'_rowavg'", "]", "=", "rowavg" ]

[ "Summarize", "scattering", "patterns", "and", "curves", "for", "all", "samples", "defined", "by", "the", "global", "allsamplenames", ".", "Inputs", ":", "reintegrate", "(", "bool", "default", "=", "True", ")", ":", "if", "the", "curves", "are", "to", "be", "obained", "by", "reintegrating", "the", "patterns", ".", "Otherwise", "1D", "curves", "are", "loaded", ".", "dist_tolerance", "(", "float", "default", "=", "3", ")", ":", "sample", "-", "to", "-", "detector", "distances", "nearer", "than", "this", "are", "considered", "the", "same", "qranges", "(", "dict", ")", ":", "a", "dictionary", "mapping", "approximate", "sample", "-", "to", "-", "detector", "distances", "(", "within", "dist_tolerance", ")", "to", "one", "-", "dimensional", "np", ".", "ndarrays", "of", "the", "desired", "q", "-", "range", "of", "the", "reintegration", ".", "samples", "(", "list", "or", "None", ")", ":", "the", "names", "of", "the", "samples", "to", "summarize", ".", "If", "None", "all", "samples", "defined", "by", "allsamplenames", "are", "used", ".", "raw", "(", "bool", "default", "=", "False", ")", ":", "if", "raw", "images", "are", "to", "be", "treated", "instead", "the", "evaluated", "ones", "(", "default", ")", ".", "late_radavg", "(", "bool", "default", "=", "True", ")", ":", "if", "the", "scattering", "curves", "are", "to", "be", "calculated", "from", "the", "summarized", "scattering", "pattern", ".", "If", "False", "scattering", "curves", "are", "calculated", "from", "each", "pattern", "and", "will", "be", "averaged", ".", "graph_ncols", ":", "the", "number", "of", "columns", "in", "graphs", "(", "2D", "patterns", "correlation", "matrices", ")", "std_multiplier", ":", "if", "the", "absolute", "value", "of", "the", "relative", "discrepancy", "is", "larger", "than", "this", "limit", "the", "exposure", "is", "deemed", "an", "outlier", ".", "graph_extension", ":", "the", "extension", "of", "the", "produced", "hardcopy", "files", ".", "graph_dpi", ":", "resolution", "of", "the", "graphs", "correlmatrix_colormap", ":", "name", "of", "the", "colormap", "to", "be", "used", "for", "the", "correlation", "matrices", "(", "resolved", "by", "matplotlib", ".", "cm", ".", "get_cmap", "()", ")", "image_colormap", ":", "name", "of", "the", "colormap", "to", "be", "used", "for", "the", "scattering", "patterns", "(", "resolved", "by", "matplotlib", ".", "cm", ".", "get_cmap", "()", ")", "correlmatrix_logarithmic", ":", "if", "the", "correlation", "matrix", "has", "to", "be", "calculated", "from", "the", "logarithm", "of", "the", "intensity", "." ]

[ "def", "volume_create", "(", "name", ",", "size", "=", "100", ",", "snapshot", "=", "None", ",", "voltype", "=", "None", ",", "profile", "=", "None", ",", "*", "*", "kwargs", ")", ":", "conn", "=", "_auth", "(", "profile", ",", "*", "*", "kwargs", ")", "return", "conn", ".", "volume_create", "(", "name", ",", "size", ",", "snapshot", ",", "voltype", ")" ]

[ "Create", "a", "block", "storage", "volume" ]

[ "def", "unregister", "(", "self", ",", "bucket", ",", "name", ")", ":", "assert", "bucket", "in", "self", ",", "'Bucket %s is unknown'", "%", "bucket", "if", "not", "name", "in", "self", "[", "bucket", "]", ":", "raise", "NotRegistered", "(", "'The function %s is not registered'", "%", "name", ")", "del", "self", "[", "bucket", "]", "[", "name", "]" ]

[ "Remove", "the", "function", "from", "the", "registry", "by", "name" ]

[ "def", "data_transforms_cifar10", "(", "args", ")", ":", "cifar_mean", "=", "[", "0.49139968", ",", "0.48215827", ",", "0.44653124", "]", "cifar_std", "=", "[", "0.24703233", ",", "0.24348505", ",", "0.26158768", "]", "train_transform", "=", "transforms", ".", "Compose", "(", "[", "transforms", ".", "RandomCrop", "(", "32", ",", "padding", "=", "4", ")", ",", "transforms", ".", "RandomHorizontalFlip", "(", ")", ",", "transforms", ".", "ToTensor", "(", ")", ",", "transforms", ".", "Normalize", "(", "cifar_mean", ",", "cifar_std", ")", ",", "]", ")", "if", "args", ".", "cutout", ":", "train_transform", ".", "transforms", ".", "append", "(", "Cutout", "(", "args", ".", "cutout_length", ")", ")", "valid_transform", "=", "transforms", ".", "Compose", "(", "[", "transforms", ".", "ToTensor", "(", ")", ",", "transforms", ".", "Normalize", "(", "cifar_mean", ",", "cifar_std", ")", "]", ")", "return", "train_transform", ",", "valid_transform" ]

[ "data_transforms", "for", "cifar10", "dataset" ]

[ "def", "ms_contrast_restore", "(", "self", ",", "viewer", ",", "event", ",", "data_x", ",", "data_y", ",", "msg", "=", "True", ")", ":", "if", "self", ".", "cancmap", "and", "(", "event", ".", "state", "==", "'down'", ")", ":", "self", ".", "restore_contrast", "(", "viewer", ",", "msg", "=", "msg", ")", "return", "True" ]

[ "An", "interactive", "way", "to", "restore", "the", "colormap", "contrast", "settings", "after", "a", "warp", "operation", "." ]

[ "def", "apply", "(", "self", ",", "doc", ")", ":", "if", "not", "isinstance", "(", "doc", ",", "Document", ")", ":", "raise", "TypeError", "(", "\"Input Contexts to MentionCaptions.apply() must be of type Document\"", ")", "for", "caption", "in", "doc", ".", "captions", ":", "yield", "TemporaryCaptionMention", "(", "caption", ")" ]

[ "Generate", "MentionCaptions", "from", "a", "Document", "by", "parsing", "all", "of", "its", "Captions", "." ]

[ "def", "_compute_next_Phi", "(", "Phi_prev", ",", "x", ",", "y", ",", "direction", ",", "A", "=", "None", ",", "extnrm", "=", "None", ",", "return_norm", "=", "True", ")", ":", "[", "rx1", ",", "n", ",", "rx2", "]", "=", "x", ".", "shape", "[", "ry1", ",", "m", ",", "ry2", "]", "=", "y", ".", "shape", "if", "A", "is", "not", "None", ":", "if", "isinstance", "(", "A", ",", "list", ")", ":", "# ?????????????????????????????????", "# A is a canonical block", "ra", "=", "len", "(", "A", ")", "else", ":", "# Just full format", "[", "ra1", ",", "ra2", "]", "=", "A", ".", "shape", "ra1", "=", "ra1", "//", "n", "ra2", "=", "ra2", "//", "m", "# ?????????????????????????????????????", "else", ":", "[", "ra1", ",", "ra2", "]", "=", "[", "1", ",", "1", "]", "if", "isinstance", "(", "Phi_prev", ",", "list", ")", ":", "Phi", "=", "[", "None", "]", "*", "ra", "if", "return_norm", ":", "nrm", "=", "0", "if", "(", "direction", "==", "'lr'", ")", ":", "# lr: Phi1", "x", "=", "_reshape", "(", "x", ",", "(", "rx1", ",", "n", "*", "rx2", ")", ")", "y", "=", "_reshape", "(", "y", ",", "(", "ry1", "*", "m", ",", "ry2", ")", ")", "for", "i", "in", "xrange", "(", "ra", ")", ":", "Phi", "[", "i", "]", "=", "_np", ".", "dot", "(", "_tconj", "(", "x", ")", ",", "Phi_prev", "[", "i", "]", ")", "Phi", "[", "i", "]", "=", "_reshape", "(", "Phi", "[", "i", "]", ",", "(", "n", ",", "rx2", "*", "ry1", ")", ")", "Phi", "[", "i", "]", "=", "Phi", "[", "i", "]", ".", "T", "Phi", "[", "i", "]", "=", "_np", ".", "dot", "(", "Phi", "[", "i", "]", ",", "A", "[", "i", "]", ")", "Phi", "[", "i", "]", "=", "_reshape", "(", "Phi", "[", "i", "]", ",", "(", "rx2", ",", "ry1", "*", "m", ")", ")", "Phi", "[", "i", "]", "=", "_np", ".", "dot", "(", "Phi", "[", "i", "]", ",", "y", ")", "if", "return_norm", ":", "nrm", "=", "max", "(", "nrm", ",", "_np", ".", "linalg", ".", "norm", "(", "Phi", "[", "i", "]", ")", ")", "# , 'fro'))", "else", ":", "# rl: Phi2", "y", "=", "_reshape", "(", "y", ",", "(", "ry1", ",", "m", "*", "ry2", ")", ")", "x", "=", "_reshape", "(", "x", ",", "(", "rx1", "*", "n", ",", "rx2", ")", ")", "for", "i", "in", "xrange", "(", "ra", ")", ":", "Phi", "[", "i", "]", "=", "_np", ".", "dot", "(", "Phi_prev", "[", "i", "]", ",", "x", ".", "T", ")", "Phi", "[", "i", "]", "=", "_reshape", "(", "Phi", "[", "i", "]", ",", "(", "ry2", "*", "rx1", ",", "n", ")", ")", "Phi", "[", "i", "]", "=", "_np", ".", "dot", "(", "Phi", "[", "i", "]", ",", "A", "[", "i", "]", ")", "Phi", "[", "i", "]", "=", "Phi", "[", "i", "]", ".", "T", "Phi", "[", "i", "]", "=", "_reshape", "(", "Phi", "[", "i", "]", ",", "(", "m", "*", "ry2", ",", "rx1", ")", ")", "Phi", "[", "i", "]", "=", "_np", ".", "dot", "(", "y", ",", "Phi", "[", "i", "]", ")", "if", "return_norm", ":", "nrm", "=", "max", "(", "nrm", ",", "_np", ".", "linalg", ".", "norm", "(", "Phi", "[", "i", "]", ")", ")", "# , 'fro'))", "if", "return_norm", ":", "# Extract the scale to prevent overload", "if", "(", "nrm", ">", "0", ")", ":", "for", "i", "in", "xrange", "(", "ra", ")", ":", "Phi", "[", "i", "]", "=", "Phi", "[", "i", "]", "/", "nrm", "else", ":", "nrm", "=", "1", "elif", "extnrm", "is", "not", "None", ":", "# Override the normalization", "for", "i", "in", "xrange", "(", "ra", ")", ":", "Phi", "[", "i", "]", "=", "Phi", "[", "i", "]", "/", "extnrm", "else", ":", "if", "(", "direction", "==", "'lr'", ")", ":", "# lr: Phi1", "x", "=", "_reshape", "(", "x", ",", "(", "rx1", ",", "n", "*", "rx2", ")", ")", "Phi", "=", "_reshape", "(", "Phi_prev", ",", "(", "rx1", ",", "ry1", "*", "ra1", ")", ")", "Phi", "=", "_np", ".", "dot", "(", "_tconj", "(", "x", ")", ",", "Phi", ")", "if", "A", "is", "not", "None", ":", "Phi", "=", "_reshape", "(", "Phi", ",", "(", "n", "*", "rx2", "*", "ry1", ",", "ra1", ")", ")", "Phi", "=", "Phi", ".", "T", "Phi", "=", "_reshape", "(", "Phi", ",", "(", "ra1", "*", "n", ",", "rx2", "*", "ry1", ")", ")", "Phi", "=", "_np", ".", "dot", "(", "A", ".", "T", ",", "Phi", ")", "Phi", "=", "_reshape", "(", "Phi", ",", "(", "m", ",", "ra2", "*", "rx2", "*", "ry1", ")", ")", "else", ":", "Phi", "=", "_reshape", "(", "Phi", ",", "(", "n", ",", "rx2", "*", "ry1", ")", ")", "Phi", "=", "Phi", ".", "T", "Phi", "=", "_reshape", "(", "Phi", ",", "(", "ra2", "*", "rx2", ",", "ry1", "*", "m", ")", ")", "y", "=", "_reshape", "(", "y", ",", "(", "ry1", "*", "m", ",", "ry2", ")", ")", "Phi", "=", "_np", ".", "dot", "(", "Phi", ",", "y", ")", "if", "A", "is", "not", "None", ":", "Phi", "=", "_reshape", "(", "Phi", ",", "(", "ra2", ",", "rx2", "*", "ry2", ")", ")", "Phi", "=", "Phi", ".", "T", "Phi", "=", "_reshape", "(", "Phi", ",", "(", "rx2", ",", "ry2", ",", "ra2", ")", ")", "else", ":", "Phi", "=", "_reshape", "(", "Phi", ",", "(", "rx2", ",", "ry2", ")", ")", "else", ":", "# rl: Phi2", "y", "=", "_reshape", "(", "y", ",", "(", "ry1", "*", "m", ",", "ry2", ")", ")", "Phi", "=", "_reshape", "(", "Phi_prev", ",", "(", "ry2", ",", "ra2", "*", "rx2", ")", ")", "Phi", "=", "_np", ".", "dot", "(", "y", ",", "Phi", ")", "if", "A", "is", "not", "None", ":", "Phi", "=", "_reshape", "(", "Phi", ",", "(", "ry1", ",", "m", "*", "ra2", "*", "rx2", ")", ")", "Phi", "=", "Phi", ".", "T", "Phi", "=", "_reshape", "(", "Phi", ",", "(", "m", "*", "ra2", ",", "rx2", "*", "ry1", ")", ")", "Phi", "=", "_np", ".", "dot", "(", "A", ",", "Phi", ")", "Phi", "=", "_reshape", "(", "Phi", ",", "(", "ra1", "*", "n", "*", "rx2", ",", "ry1", ")", ")", "Phi", "=", "Phi", ".", "T", "Phi", "=", "_reshape", "(", "Phi", ",", "(", "ry1", "*", "ra1", ",", "n", "*", "rx2", ")", ")", "x", "=", "_reshape", "(", "x", ",", "(", "rx1", ",", "n", "*", "rx2", ")", ")", "Phi", "=", "_np", ".", "dot", "(", "Phi", ",", "_tconj", "(", "x", ")", ")", "if", "A", "is", "not", "None", ":", "Phi", "=", "_reshape", "(", "Phi", ",", "(", "ry1", ",", "ra1", ",", "rx1", ")", ")", "else", ":", "Phi", "=", "_reshape", "(", "Phi", ",", "(", "ry1", ",", "rx1", ")", ")", "if", "return_norm", ":", "# Extract the scale to prevent overload", "nrm", "=", "_np", ".", "linalg", ".", "norm", "(", "Phi", ")", "# , 'fro')", "if", "(", "nrm", ">", "0", ")", ":", "Phi", "=", "Phi", "/", "nrm", "else", ":", "nrm", "=", "1", "elif", "extnrm", "is", "not", "None", ":", "# Override the normalization by the external one", "Phi", "=", "Phi", "/", "extnrm", "if", "return_norm", ":", "return", "Phi", ",", "nrm", "else", ":", "return", "Phi" ]

[ "Performs", "the", "recurrent", "Phi", "(", "or", "Psi", ")", "matrix", "computation", "Phi", "=", "Phi_prev", "*", "(", "x", "Ay", ")", ".", "If", "direction", "is", "lr", "computes", "Psi", "if", "direction", "is", "rl", "computes", "Phi", "A", "can", "be", "empty", "then", "only", "x", "y", "is", "computed", "." ]

[ "def", "add_init_service_checks", "(", "nrpe", ",", "services", ",", "unit_name", ",", "immediate_check", "=", "True", ")", ":", "for", "svc", "in", "services", ":", "# Don't add a check for these services from neutron-gateway", "if", "svc", "in", "[", "'ext-port'", ",", "'os-charm-phy-nic-mtu'", "]", ":", "next", "upstart_init", "=", "'/etc/init/%s.conf'", "%", "svc", "sysv_init", "=", "'/etc/init.d/%s'", "%", "svc", "if", "host", ".", "init_is_systemd", "(", ")", ":", "nrpe", ".", "add_check", "(", "shortname", "=", "svc", ",", "description", "=", "'process check {%s}'", "%", "unit_name", ",", "check_cmd", "=", "'check_systemd.py %s'", "%", "svc", ")", "elif", "os", ".", "path", ".", "exists", "(", "upstart_init", ")", ":", "nrpe", ".", "add_check", "(", "shortname", "=", "svc", ",", "description", "=", "'process check {%s}'", "%", "unit_name", ",", "check_cmd", "=", "'check_upstart_job %s'", "%", "svc", ")", "elif", "os", ".", "path", ".", "exists", "(", "sysv_init", ")", ":", "cronpath", "=", "'/etc/cron.d/nagios-service-check-%s'", "%", "svc", "checkpath", "=", "'%s/service-check-%s.txt'", "%", "(", "nrpe", ".", "homedir", ",", "svc", ")", "croncmd", "=", "(", "'/usr/local/lib/nagios/plugins/check_exit_status.pl '", "'-e -s /etc/init.d/%s status'", "%", "svc", ")", "cron_file", "=", "'*/5 * * * * root %s > %s\\n'", "%", "(", "croncmd", ",", "checkpath", ")", "f", "=", "open", "(", "cronpath", ",", "'w'", ")", "f", ".", "write", "(", "cron_file", ")", "f", ".", "close", "(", ")", "nrpe", ".", "add_check", "(", "shortname", "=", "svc", ",", "description", "=", "'service check {%s}'", "%", "unit_name", ",", "check_cmd", "=", "'check_status_file.py -f %s'", "%", "checkpath", ",", ")", "# if /var/lib/nagios doesn't exist open(checkpath, 'w') will fail", "# (LP: #1670223).", "if", "immediate_check", "and", "os", ".", "path", ".", "isdir", "(", "nrpe", ".", "homedir", ")", ":", "f", "=", "open", "(", "checkpath", ",", "'w'", ")", "subprocess", ".", "call", "(", "croncmd", ".", "split", "(", ")", ",", "stdout", "=", "f", ",", "stderr", "=", "subprocess", ".", "STDOUT", ")", "f", ".", "close", "(", ")", "os", ".", "chmod", "(", "checkpath", ",", "0o644", ")" ]

[ "Add", "checks", "for", "each", "service", "in", "list" ]

[ "def", "_get_from_prototype", "(", "self", ",", "factory", ",", "svc_registration", ")", ":", "# type: (Any, ServiceRegistration) -> Any", "svc_ref", "=", "svc_registration", ".", "get_reference", "(", ")", "service", "=", "factory", ".", "get_service", "(", "self", ".", "__bundle", ",", "svc_registration", ")", "try", ":", "# Check if the service already exists", "services", ",", "counter", "=", "self", ".", "__factored", "[", "svc_ref", "]", "services", ".", "append", "(", "service", ")", "counter", ".", "inc", "(", ")", "except", "KeyError", ":", "counter", "=", "_UsageCounter", "(", ")", "counter", ".", "inc", "(", ")", "# Store the counter", "self", ".", "__factored", "[", "svc_ref", "]", "=", "(", "[", "service", "]", ",", "counter", ")", "return", "service" ]

[ "Returns", "a", "service", "instance", "from", "a", "Prototype", "Service", "Factory" ]

[ "def", "get_autotype", "(", "arr", ")", ":", "try", ":", "narr", "=", "arr", ".", "astype", "(", "'float'", ")", "if", "(", "narr", "<", "sys", ".", "maxsize", ")", ".", "all", "(", ")", "and", "(", "narr", "%", "1", ")", ".", "sum", "(", ")", "==", "0", ":", "return", "narr", ".", "astype", "(", "'int'", ")", "else", ":", "return", "narr", "except", "ValueError", ":", "return", "arr" ]

[ "Attempts", "to", "return", "a", "numpy", "array", "converted", "to", "the", "most", "sensible", "dtype", "Value", "errors", "will", "be", "caught", "and", "simply", "return", "the", "original", "array", "Tries", "to", "make", "dtype", "int", "then", "float", "then", "no", "change" ]

[ "def", "_delete", "(", "self", ",", "uri", ")", ":", "headers", "=", "self", ".", "_get_headers", "(", ")", "response", "=", "self", ".", "session", ".", "delete", "(", "uri", ",", "headers", "=", "headers", ")", "# Will return a 204 on successful delete", "if", "response", ".", "status_code", "==", "204", ":", "return", "response", "else", ":", "logging", ".", "error", "(", "response", ".", "content", ")", "response", ".", "raise_for_status", "(", ")" ]

[ "Simple", "DELETE", "operation", "for", "a", "given", "path", "." ]

[ "def", "set_scrollbar_position", "(", "self", ",", "position", ")", ":", "# Scrollbars will be restored after the expanded state\r", "self", ".", "_scrollbar_positions", "=", "position", "if", "self", ".", "_to_be_loaded", "is", "not", "None", "and", "len", "(", "self", ".", "_to_be_loaded", ")", "==", "0", ":", "self", ".", "restore_scrollbar_positions", "(", ")" ]

[ "Set", "scrollbar", "positions" ]

[ "def", "topoSort", "(", "roots", ",", "getParents", ")", ":", "results", "=", "[", "]", "visited", "=", "set", "(", ")", "# Use iterative version to avoid stack limits for large datasets", "stack", "=", "[", "(", "node", ",", "0", ")", "for", "node", "in", "roots", "]", "while", "stack", ":", "current", ",", "state", "=", "stack", ".", "pop", "(", ")", "if", "state", "==", "0", ":", "# before recursing", "if", "current", "not", "in", "visited", ":", "visited", ".", "add", "(", "current", ")", "stack", ".", "append", "(", "(", "current", ",", "1", ")", ")", "stack", ".", "extend", "(", "(", "parent", ",", "0", ")", "for", "parent", "in", "getParents", "(", "current", ")", ")", "else", ":", "# after recursing", "assert", "(", "current", "in", "visited", ")", "results", ".", "append", "(", "current", ")", "return", "results" ]

[ "Return", "a", "topological", "sorting", "of", "nodes", "in", "a", "graph", "." ]

[ "def", "throw_random_private", "(", "lengths", ",", "regions", ",", "save_interval_func", ",", "allow_overlap", "=", "False", ",", "three_args", "=", "True", ")", ":", "# Implementation:", "# We keep a list of the regions, sorted from largest to smallest. We then", "# place each length by following steps:", "# (1) construct a candidate counts array (cc array)", "# (2) choose a candidate at random", "# (3) find region containing that candidate", "# (4) map candidate to position in that region", "# (5) split region if not allowing overlaps", "# (6) report placed segment", "#", "# The cc array is only constructed if there's a change (different length", "# to place, or the region list has changed). It contains, for each", "# region, the total number of number of candidate positions in regions", "# *preceding* it in the region list:", "# cc[i] = sum over k in 0..(i-1) of length[i] - L + 1", "# where N is the number of regions and L is the length being thrown.", "# At the same time, we determine the total number of candidates (the total", "# number of places the current length can be placed) and the index range", "# of regions into which the length will fit.", "#", "# example:", "# for L = 20", "# i = 0 1 2 3 4 5 6 7 8 9", "# length[i] = 96 66 56 50 48 40 29 17 11 8", "# cc[i] = 0 77 124 161 192 221 242 X X X", "# candidates = 252", "# lo_rgn = 0", "# hi_rgn = 6", "#", "# The candidate is chosen in (0..candidates-1). The candidate counts", "# array allows us to do a binary search to locate the region that holds that", "# candidate. Continuing the example above, we choose a random candidate", "# s in (0..251). If s happens to be in (124..160), it will be mapped to", "# region 2 at start position s-124.", "#", "# During the binary search, if we are looking at region 3, if s < cc[3]", "# then the desired region is region 2 or lower. Otherwise it is region 3 or", "# higher.", "min_length", "=", "min", "(", "lengths", ")", "prev_length", "=", "None", "# (force initial cc array construction)", "cc", "=", "[", "0", "]", "*", "(", "len", "(", "regions", ")", "+", "len", "(", "lengths", ")", "-", "1", ")", "num_thrown", "=", "0", "for", "length", "in", "lengths", ":", "# construct cc array (only needed if length has changed or region list has", "# changed)", "if", "length", "!=", "prev_length", ":", "prev_length", "=", "length", "assert", "len", "(", "cc", ")", ">=", "len", "(", "regions", ")", "candidates", "=", "0", "hi_rgn", "=", "0", "for", "region", "in", "regions", ":", "rgn_len", "=", "region", "[", "0", "]", "if", "rgn_len", "<", "length", ":", "break", "cc", "[", "hi_rgn", "]", "=", "candidates", "candidates", "+=", "rgn_len", "-", "length", "+", "1", "hi_rgn", "+=", "1", "if", "candidates", "==", "0", ":", "raise", "MaxtriesException", "(", "\"No region can fit an interval of length %d (we threw %d of %d)\"", "%", "(", "length", ",", "num_thrown", ",", "len", "(", "lengths", ")", ")", ")", "hi_rgn", "-=", "1", "# Select a candidate", "s", "=", "random", ".", "randrange", "(", "candidates", ")", "#..", "#..for ix in range( len( regions ) ):", "#.. region = regions[ix]", "#.. if ix <= hi_rgn: print \"%2s: %5s %5s %5s\" % ( ix, region[1], region[0], cc[ix] )", "#.. else: print \"%2s: %5s %5s %5s\" % ( ix, region[1], region[0], \"X\" )", "#..print \"s = %s (of %s candidates)\" % ( s, candidates )", "# Locate region containing that candidate, by binary search", "lo", "=", "0", "hi", "=", "hi_rgn", "while", "hi", ">", "lo", ":", "mid", "=", "(", "lo", "+", "hi", "+", "1", ")", "/", "2", "# (we round up to prevent infinite loop)", "if", "s", "<", "cc", "[", "mid", "]", ":", "hi", "=", "mid", "-", "1", "# (s < num candidates from 0..mid-1)", "else", ":", "lo", "=", "mid", "# (s >= num candidates from 0..mid-1)", "s", "-=", "cc", "[", "lo", "]", "# If we are not allowing overlaps we will remove the placed interval", "# from the region list", "if", "allow_overlap", ":", "rgn_length", ",", "rgn_start", ",", "rgn_extra", "=", "regions", "[", "lo", "]", "else", ":", "# Remove the chosen region and split", "rgn_length", ",", "rgn_start", ",", "rgn_extra", "=", "regions", ".", "pop", "(", "lo", ")", "rgn_end", "=", "rgn_start", "+", "rgn_length", "assert", "s", ">=", "0", "assert", "rgn_start", "+", "s", "+", "length", "<=", "rgn_end", ",", "\"Expected: %d + %d + %d == %d <= %d\"", "%", "(", "rgn_start", ",", "s", ",", "length", ",", "rgn_start", "+", "s", "+", "length", ",", "rgn_end", ")", "regions", ".", "reverse", "(", ")", "if", "s", ">=", "min_length", ":", "bisect", ".", "insort", "(", "regions", ",", "(", "s", ",", "rgn_start", ",", "rgn_extra", ")", ")", "if", "s", "+", "length", "<=", "rgn_length", "-", "min_length", ":", "bisect", ".", "insort", "(", "regions", ",", "(", "rgn_length", "-", "(", "s", "+", "length", ")", ",", "rgn_start", "+", "s", "+", "length", ",", "rgn_extra", ")", ")", "regions", ".", "reverse", "(", ")", "prev_length", "=", "None", "# (force cc array construction)", "# Save the new interval", "if", "(", "three_args", ")", ":", "save_interval_func", "(", "rgn_start", "+", "s", ",", "rgn_start", "+", "s", "+", "length", ",", "rgn_extra", ")", "else", ":", "save_interval_func", "(", "rgn_start", "+", "s", ",", "rgn_start", "+", "s", "+", "length", ")", "num_thrown", "+=", "1" ]

[ "(", "Internal", "function", ";", "we", "expect", "calls", "only", "through", "the", "interface", "functions", "above", ")", "lengths", ":", "A", "list", "containing", "the", "length", "of", "each", "interval", "to", "be", "generated", ".", "regions", ":", "A", "list", "of", "regions", "in", "which", "intervals", "can", "be", "placed", "sorted", "by", "decreasing", "length", ".", "Elements", "are", "triples", "of", "the", "form", "(", "length", "start", "extra", ")", "This", "list", "CAN", "BE", "MODIFIED", "by", "this", "function", ".", "save_interval_func", ":", "A", "function", "accepting", "three", "arguments", "which", "will", "be", "passed", "the", "(", "start", "stop", "extra", ")", "for", "each", "generated", "interval", "." ]

[ "def", "predict", "(", "self", ",", "document_path", ":", "str", ",", "model_name", ":", "str", ",", "consent_id", ":", "str", "=", "None", ")", "->", "Prediction", ":", "content_type", "=", "self", ".", "_get_content_type", "(", "document_path", ")", "consent_id", "=", "consent_id", "or", "str", "(", "uuid4", "(", ")", ")", "document_id", "=", "self", ".", "_upload_document", "(", "document_path", ",", "content_type", ",", "consent_id", ")", "prediction_response", "=", "self", ".", "post_predictions", "(", "document_id", ",", "model_name", ")", "return", "Prediction", "(", "document_id", ",", "consent_id", ",", "model_name", ",", "prediction_response", ")" ]

[ "Run", "inference", "and", "create", "prediction", "on", "document", ".", "This", "method", "takes", "care", "of", "creating", "and", "uploading", "a", "document", "specified", "by", "document_path", ".", "as", "well", "as", "running", "inference", "using", "model", "specified", "by", "model_name", "to", "create", "prediction", "on", "the", "document", "." ]

[ "def", "get_request", "(", "self", ",", "request", ")", ":", "request", ".", "layer", "=", "self", ".", "_parse_layer", "(", "request", ".", "layer", ",", "return_wms_name", "=", "True", ")", "return", "super", "(", ")", ".", "get_request", "(", "request", ")" ]

[ "Get", "a", "list", "of", "DownloadRequests", "for", "all", "data", "that", "are", "under", "the", "given", "field", "in", "the", "table", "of", "a", "Geopedia", "layer", "." ]

[ "def", "validate_request_success", "(", "response_text", ",", "request_url", ",", "status_code", ",", "expected_status_code", ")", ":", "try", ":", "assert", "status_code", "==", "expected_status_code", "except", "AssertionError", ":", "msg", "=", "(", "\"Request to {url} failed with status {status_code}:\\n\"", "\"The reponse from the request was as follows:\\n\\n\"", "\"{content}\"", ")", ".", "format", "(", "url", "=", "request_url", ",", "status_code", "=", "status_code", ",", "content", "=", "response_text", ")", "raise", "BadHttpRequestError", "(", "msg", ")" ]

[ "Validates", "that", "a", "request", "was", "successful", "." ]

[ "def", "centerOnDateTime", "(", "self", ",", "dtime", ")", ":", "view", "=", "self", ".", "uiGanttVIEW", "scene", "=", "view", ".", "scene", "(", ")", "point", "=", "view", ".", "mapToScene", "(", "0", ",", "0", ")", "x", "=", "scene", ".", "datetimeXPos", "(", "dtime", ")", "y", "=", "point", ".", "y", "(", ")", "view", ".", "centerOn", "(", "x", ",", "y", ")" ]

[ "Centers", "the", "view", "on", "a", "given", "datetime", "for", "the", "gantt", "widget", ".", ":", "param", "dtime", "|", "<QDateTime", ">" ]

[ "def", "register", "(", "cls", ",", "name", ")", ":", "def", "decorate", "(", "klazz", ")", ":", "\"\"\" Decorator. \"\"\"", "if", "name", "in", "cls", ".", "_events", ":", "raise", "GerritError", "(", "\"Duplicate event: %s\"", "%", "name", ")", "cls", ".", "_events", "[", "name", "]", "=", "[", "klazz", ".", "__module__", ",", "klazz", ".", "__name__", "]", "klazz", ".", "name", "=", "name", "return", "klazz", "return", "decorate" ]

[ "Decorator", "to", "register", "the", "event", "identified", "by", "name", "." ]

[ "def", "extract_datetime_hour", "(", "cls", ",", "datetime_str", ")", ":", "if", "not", "datetime_str", ":", "raise", "DateTimeFormatterException", "(", "'datetime_str must a valid string'", ")", "try", ":", "return", "cls", ".", "_extract_timestamp", "(", "datetime_str", ",", "cls", ".", "DATETIME_HOUR_FORMAT", ")", "except", "(", "TypeError", ",", "ValueError", ")", ":", "raise", "DateTimeFormatterException", "(", "'Invalid datetime string {}.'", ".", "format", "(", "datetime_str", ")", ")" ]

[ "Tries", "to", "extract", "a", "datetime", "object", "from", "the", "given", "string", "including", "only", "hours", "." ]

[ "def", "from_definition", "(", "cls", ",", "defn", ",", "names", "=", "{", "}", ")", ":", "repls", "=", "map", "(", "Repl", ".", "from_defn", ",", "defn", ".", "get", "(", "'replace'", ",", "[", "]", ")", ")", "self", "=", "cls", "(", "repls", ")", "vars", "(", "self", ")", ".", "update", "(", "names", ")", "vars", "(", "self", ")", ".", "update", "(", "defn", ".", "get", "(", "'using'", ",", "{", "}", ")", ")", "return", "self" ]

[ "A", "definition", "may", "contain", "the", "following", "members", ":" ]

[ "def", "brain", "(", "draw", "=", "True", ",", "show", "=", "True", ",", "fiducial", "=", "True", ",", "flat", "=", "True", ",", "inflated", "=", "True", ",", "subject", "=", "'S1'", ",", "interval", "=", "1000", ",", "uv", "=", "True", ",", "color", "=", "None", ")", ":", "import", "ipyvolume", "as", "ipv", "try", ":", "import", "cortex", "except", ":", "warnings", ".", "warn", "(", "\"it seems pycortex is not installed, which is needed for this example\"", ")", "raise", "xlist", ",", "ylist", ",", "zlist", "=", "[", "]", ",", "[", "]", ",", "[", "]", "polys_list", "=", "[", "]", "def", "add", "(", "pts", ",", "polys", ")", ":", "xlist", ".", "append", "(", "pts", "[", ":", ",", "0", "]", ")", "ylist", ".", "append", "(", "pts", "[", ":", ",", "1", "]", ")", "zlist", ".", "append", "(", "pts", "[", ":", ",", "2", "]", ")", "polys_list", ".", "append", "(", "polys", ")", "def", "n", "(", "x", ")", ":", "return", "(", "x", "-", "x", ".", "min", "(", ")", ")", "/", "x", ".", "ptp", "(", ")", "if", "fiducial", "or", "color", "is", "True", ":", "pts", ",", "polys", "=", "cortex", ".", "db", ".", "get_surf", "(", "'S1'", ",", "'fiducial'", ",", "merge", "=", "True", ")", "x", ",", "y", ",", "z", "=", "pts", ".", "T", "r", "=", "n", "(", "x", ")", "g", "=", "n", "(", "y", ")", "b", "=", "n", "(", "z", ")", "if", "color", "is", "True", ":", "color", "=", "np", ".", "array", "(", "[", "r", ",", "g", ",", "b", "]", ")", ".", "T", ".", "copy", "(", ")", "else", ":", "color", "=", "None", "if", "fiducial", ":", "add", "(", "pts", ",", "polys", ")", "else", ":", "if", "color", "is", "False", ":", "color", "=", "None", "if", "inflated", ":", "add", "(", "*", "cortex", ".", "db", ".", "get_surf", "(", "'S1'", ",", "'inflated'", ",", "merge", "=", "True", ",", "nudge", "=", "True", ")", ")", "u", "=", "v", "=", "None", "if", "flat", "or", "uv", ":", "pts", ",", "polys", "=", "cortex", ".", "db", ".", "get_surf", "(", "'S1'", ",", "'flat'", ",", "merge", "=", "True", ",", "nudge", "=", "True", ")", "x", ",", "y", ",", "z", "=", "pts", ".", "T", "u", "=", "n", "(", "x", ")", "v", "=", "n", "(", "y", ")", "if", "flat", ":", "add", "(", "pts", ",", "polys", ")", "polys_list", ".", "sort", "(", "key", "=", "lambda", "x", ":", "len", "(", "x", ")", ")", "polys", "=", "polys_list", "[", "0", "]", "if", "draw", ":", "if", "color", "is", "None", ":", "mesh", "=", "ipv", ".", "plot_trisurf", "(", "xlist", ",", "ylist", ",", "zlist", ",", "polys", ",", "u", "=", "u", ",", "v", "=", "v", ")", "else", ":", "mesh", "=", "ipv", ".", "plot_trisurf", "(", "xlist", ",", "ylist", ",", "zlist", ",", "polys", ",", "color", "=", "color", ",", "u", "=", "u", ",", "v", "=", "v", ")", "if", "show", ":", "if", "len", "(", "x", ")", ">", "1", ":", "ipv", ".", "animation_control", "(", "mesh", ",", "interval", "=", "interval", ")", "ipv", ".", "squarelim", "(", ")", "ipv", ".", "show", "(", ")", "return", "mesh", "else", ":", "return", "xlist", ",", "ylist", ",", "zlist", ",", "polys" ]

[ "Show", "a", "human", "brain", "model", "." ]

[ "def", "write_state_file", "(", "self", ")", ":", "fh", "=", "open", "(", "'awsproviderstate.json'", ",", "'w'", ")", "state", "=", "{", "}", "state", "[", "'vpcID'", "]", "=", "self", ".", "vpc_id", "state", "[", "'sgID'", "]", "=", "self", ".", "sg_id", "state", "[", "'snIDs'", "]", "=", "self", ".", "sn_ids", "state", "[", "'instances'", "]", "=", "self", ".", "instances", "state", "[", "\"instanceState\"", "]", "=", "self", ".", "instance_states", "fh", ".", "write", "(", "json", ".", "dumps", "(", "state", ",", "indent", "=", "4", ")", ")" ]

[ "Save", "information", "that", "must", "persist", "to", "a", "file", "." ]

[ "def", "improve_model_docstring", "(", "app", ",", "what", ",", "name", ",", "obj", ",", "options", ",", "lines", ")", ":", "if", "what", "==", "'class'", ":", "_improve_class_docs", "(", "app", ",", "obj", ",", "lines", ")", "elif", "what", "==", "'attribute'", ":", "_improve_attribute_docs", "(", "obj", ",", "name", ",", "lines", ")", "elif", "what", "==", "'method'", ":", "_improve_method_docs", "(", "obj", ",", "name", ",", "lines", ")", "# Return the extended docstring", "return", "lines" ]

[ "Hook", "that", "improves", "the", "autodoc", "docstrings", "for", "Django", "models", "." ]

[ "def", "_write_script", "(", "path", ",", "lines", ",", "chmod", "=", "True", ")", ":", "if", "len", "(", "lines", ")", ">", "0", ":", "lastline", "=", "lines", ".", "pop", "(", ")", "for", "line", "in", "lines", ":", "self", ".", "install", ".", "append", "(", "'echo \"%s\" >> %s'", "%", "path", ")", "self", ".", "install", ".", "append", "(", "lastline", ")", "if", "chmod", "is", "True", ":", "self", ".", "install", ".", "append", "(", "'chmod u+x %s'", "%", "path", ")" ]

[ "write", "a", "script", "with", "some", "lines", "content", "to", "path", "in", "the", "image", ".", "This", "is", "done", "by", "way", "of", "adding", "echo", "statements", "to", "the", "install", "section", "." ]

[ "def", "_recurse", "(", "data", ",", "obj", ")", ":", "content", "=", "_ContentManager", "(", ")", "for", "child", "in", "obj", ".", "get_children", "(", ")", ":", "# Some patches are Spines, too; skip those entirely.", "# See <https://github.com/nschloe/matplotlib2tikz/issues/277>.", "if", "isinstance", "(", "child", ",", "mpl", ".", "spines", ".", "Spine", ")", ":", "continue", "if", "isinstance", "(", "child", ",", "mpl", ".", "axes", ".", "Axes", ")", ":", "ax", "=", "axes", ".", "Axes", "(", "data", ",", "child", ")", "if", "ax", ".", "is_colorbar", ":", "continue", "# add extra axis options", "if", "data", "[", "\"extra axis options [base]\"", "]", ":", "ax", ".", "axis_options", ".", "extend", "(", "data", "[", "\"extra axis options [base]\"", "]", ")", "data", "[", "\"current mpl axes obj\"", "]", "=", "child", "data", "[", "\"current axes\"", "]", "=", "ax", "# Run through the child objects, gather the content.", "data", ",", "children_content", "=", "_recurse", "(", "data", ",", "child", ")", "# populate content and add axis environment if desired", "if", "data", "[", "\"add axis environment\"", "]", ":", "content", ".", "extend", "(", "ax", ".", "get_begin_code", "(", ")", "+", "children_content", "+", "[", "ax", ".", "get_end_code", "(", "data", ")", "]", ",", "0", ")", "else", ":", "content", ".", "extend", "(", "children_content", ",", "0", ")", "# print axis environment options, if told to show infos", "if", "data", "[", "\"show_info\"", "]", ":", "print", "(", "\"=========================================================\"", ")", "print", "(", "\"These would have been the properties of the environment:\"", ")", "print", "(", "\"\"", ".", "join", "(", "ax", ".", "get_begin_code", "(", ")", "[", "1", ":", "]", ")", ")", "print", "(", "\"=========================================================\"", ")", "elif", "isinstance", "(", "child", ",", "mpl", ".", "lines", ".", "Line2D", ")", ":", "data", ",", "cont", "=", "line2d", ".", "draw_line2d", "(", "data", ",", "child", ")", "content", ".", "extend", "(", "cont", ",", "child", ".", "get_zorder", "(", ")", ")", "elif", "isinstance", "(", "child", ",", "mpl", ".", "image", ".", "AxesImage", ")", ":", "data", ",", "cont", "=", "img", ".", "draw_image", "(", "data", ",", "child", ")", "content", ".", "extend", "(", "cont", ",", "child", ".", "get_zorder", "(", ")", ")", "elif", "isinstance", "(", "child", ",", "mpl", ".", "patches", ".", "Patch", ")", ":", "data", ",", "cont", "=", "patch", ".", "draw_patch", "(", "data", ",", "child", ")", "content", ".", "extend", "(", "cont", ",", "child", ".", "get_zorder", "(", ")", ")", "elif", "isinstance", "(", "child", ",", "(", "mpl", ".", "collections", ".", "PatchCollection", ",", "mpl", ".", "collections", ".", "PolyCollection", ")", ")", ":", "data", ",", "cont", "=", "patch", ".", "draw_patchcollection", "(", "data", ",", "child", ")", "content", ".", "extend", "(", "cont", ",", "child", ".", "get_zorder", "(", ")", ")", "elif", "isinstance", "(", "child", ",", "mpl", ".", "collections", ".", "PathCollection", ")", ":", "data", ",", "cont", "=", "path", ".", "draw_pathcollection", "(", "data", ",", "child", ")", "content", ".", "extend", "(", "cont", ",", "child", ".", "get_zorder", "(", ")", ")", "elif", "isinstance", "(", "child", ",", "mpl", ".", "collections", ".", "LineCollection", ")", ":", "data", ",", "cont", "=", "line2d", ".", "draw_linecollection", "(", "data", ",", "child", ")", "content", ".", "extend", "(", "cont", ",", "child", ".", "get_zorder", "(", ")", ")", "elif", "isinstance", "(", "child", ",", "mpl", ".", "collections", ".", "QuadMesh", ")", ":", "data", ",", "cont", "=", "qmsh", ".", "draw_quadmesh", "(", "data", ",", "child", ")", "content", ".", "extend", "(", "cont", ",", "child", ".", "get_zorder", "(", ")", ")", "elif", "isinstance", "(", "child", ",", "mpl", ".", "legend", ".", "Legend", ")", ":", "data", "=", "legend", ".", "draw_legend", "(", "data", ",", "child", ")", "if", "data", "[", "\"legend colors\"", "]", ":", "content", ".", "extend", "(", "data", "[", "\"legend colors\"", "]", ",", "0", ")", "elif", "isinstance", "(", "child", ",", "(", "mpl", ".", "text", ".", "Text", ",", "mpl", ".", "text", ".", "Annotation", ")", ")", ":", "data", ",", "cont", "=", "text", ".", "draw_text", "(", "data", ",", "child", ")", "content", ".", "extend", "(", "cont", ",", "child", ".", "get_zorder", "(", ")", ")", "elif", "isinstance", "(", "child", ",", "(", "mpl", ".", "axis", ".", "XAxis", ",", "mpl", ".", "axis", ".", "YAxis", ")", ")", ":", "pass", "else", ":", "warnings", ".", "warn", "(", "\"matplotlib2tikz: Don't know how to handle object {}.\"", ".", "format", "(", "type", "(", "child", ")", ")", ")", "return", "data", ",", "content", ".", "flatten", "(", ")" ]

[ "Iterates", "over", "all", "children", "of", "the", "current", "object", "gathers", "the", "contents", "contributing", "to", "the", "resulting", "PGFPlots", "file", "and", "returns", "those", "." ]

[ "def", "seek", "(", "self", ",", "time", ")", ":", "res", "=", "librtmp", ".", "RTMP_SendSeek", "(", "self", ".", "client", ".", "rtmp", ",", "time", ")", "if", "res", "<", "1", ":", "raise", "RTMPError", "(", "\"Failed to seek\"", ")" ]

[ "Attempts", "to", "seek", "in", "the", "stream", "." ]

[ "def", "status", "(", "server", ",", "output", ",", "verbose", ")", ":", "if", "verbose", ":", "log", "(", "\"Connecting to Entity Matching Server: {}\"", ".", "format", "(", "server", ")", ")", "service_status", "=", "server_get_status", "(", "server", ")", "if", "verbose", ":", "log", "(", "\"Status: {}\"", ".", "format", "(", "service_status", "[", "'status'", "]", ")", ")", "print", "(", "json", ".", "dumps", "(", "service_status", ")", ",", "file", "=", "output", ")" ]

[ "Connect", "to", "an", "entity", "matching", "server", "and", "check", "the", "service", "status", "." ]

[ "def", "isosurface", "(", "image", ",", "smoothing", "=", "0", ",", "threshold", "=", "None", ",", "connectivity", "=", "False", ")", ":", "if", "smoothing", ":", "smImg", "=", "vtk", ".", "vtkImageGaussianSmooth", "(", ")", "smImg", ".", "SetDimensionality", "(", "3", ")", "smImg", ".", "SetInputData", "(", "image", ")", "smImg", ".", "SetStandardDeviations", "(", "smoothing", ",", "smoothing", ",", "smoothing", ")", "smImg", ".", "Update", "(", ")", "image", "=", "smImg", ".", "GetOutput", "(", ")", "scrange", "=", "image", ".", "GetScalarRange", "(", ")", "if", "scrange", "[", "1", "]", ">", "1e10", ":", "print", "(", "\"Warning, high scalar range detected:\"", ",", "scrange", ")", "cf", "=", "vtk", ".", "vtkContourFilter", "(", ")", "cf", ".", "SetInputData", "(", "image", ")", "cf", ".", "UseScalarTreeOn", "(", ")", "cf", ".", "ComputeScalarsOn", "(", ")", "if", "utils", ".", "isSequence", "(", "threshold", ")", ":", "cf", ".", "SetNumberOfContours", "(", "len", "(", "threshold", ")", ")", "for", "i", ",", "t", "in", "enumerate", "(", "threshold", ")", ":", "cf", ".", "SetValue", "(", "i", ",", "t", ")", "cf", ".", "Update", "(", ")", "else", ":", "if", "not", "threshold", ":", "threshold", "=", "(", "2", "*", "scrange", "[", "0", "]", "+", "scrange", "[", "1", "]", ")", "/", "3.0", "cf", ".", "SetValue", "(", "0", ",", "threshold", ")", "cf", ".", "Update", "(", ")", "clp", "=", "vtk", ".", "vtkCleanPolyData", "(", ")", "clp", ".", "SetInputConnection", "(", "cf", ".", "GetOutputPort", "(", ")", ")", "clp", ".", "Update", "(", ")", "poly", "=", "clp", ".", "GetOutput", "(", ")", "if", "connectivity", ":", "conn", "=", "vtk", ".", "vtkPolyDataConnectivityFilter", "(", ")", "conn", ".", "SetExtractionModeToLargestRegion", "(", ")", "conn", ".", "SetInputData", "(", "poly", ")", "conn", ".", "Update", "(", ")", "poly", "=", "conn", ".", "GetOutput", "(", ")", "a", "=", "Actor", "(", "poly", ",", "c", "=", "None", ")", ".", "phong", "(", ")", "a", ".", "mapper", ".", "SetScalarRange", "(", "scrange", "[", "0", "]", ",", "scrange", "[", "1", "]", ")", "return", "a" ]

[ "Return", "a", "vtkActor", "isosurface", "extracted", "from", "a", "vtkImageData", "object", "." ]