Datasets:

kejian

/

codesearchnet-python-raw

like 1

[ "def", "setup_layout", "(", "self", ",", "orientation", "=", "None", ")", ":", "if", "orientation", "==", "QtCore", ".", "Qt", ".", "Horizontal", "or", "orientation", "is", "None", ":", "layout", "=", "QtGui", ".", "QHBoxLayout", "(", ")", "elif", "orientation", "==", "QtCore", ".", "Qt", ".", "Vertical", ":", "layout", "=", "QtGui", ".", "QVBoxLayout", "(", ")", "else", ":", "raise", "TypeError", "(", "'Orientation is of wrong type! Allowed is QtCore.Qt.Horizontal and QtCore.Qt.Vertical. Given: %s'", "%", "orientation", ")", "layout", ".", "setContentsMargins", "(", "0", ",", "0", ",", "0", ",", "0", ")", "layout", ".", "setSpacing", "(", "0", ")", "self", ".", "setLayout", "(", "layout", ")" ]

[ "Setup", "the", "layout", "for", "the", "tooltip", "in", "the", "given", "orientation" ]

[ "def", "list_file_extensions", "(", "path", ":", "str", ",", "reportevery", ":", "int", "=", "1", ")", "->", "List", "[", "str", "]", ":", "extensions", "=", "set", "(", ")", "count", "=", "0", "for", "root", ",", "dirs", ",", "files", "in", "os", ".", "walk", "(", "path", ")", ":", "count", "+=", "1", "if", "count", "%", "reportevery", "==", "0", ":", "log", ".", "debug", "(", "\"Walking directory {}: {!r}\"", ",", "count", ",", "root", ")", "for", "file", "in", "files", ":", "filename", ",", "ext", "=", "os", ".", "path", ".", "splitext", "(", "file", ")", "extensions", ".", "add", "(", "ext", ")", "return", "sorted", "(", "list", "(", "extensions", ")", ")" ]

[ "Returns", "a", "sorted", "list", "of", "every", "file", "extension", "found", "in", "a", "directory", "and", "its", "subdirectories", "." ]

[ "def", "get", "(", "cls", ",", "resource_id", ",", "include_deactivated", "=", "False", ")", ":", "if", "include_deactivated", ":", "resource", "=", "yield", "cls", ".", "view", ".", "first", "(", "key", "=", "resource_id", ",", "include_docs", "=", "True", ")", "else", ":", "resource", "=", "yield", "cls", ".", "active_view", ".", "first", "(", "key", "=", "resource_id", ",", "include_docs", "=", "True", ")", "parent", "=", "cls", ".", "parent_resource", "(", "*", "*", "resource", "[", "'doc'", "]", ")", "raise", "Return", "(", "cls", "(", "parent", "=", "parent", ",", "*", "*", "resource", "[", "'value'", "]", ")", ")" ]

[ "Get", "a", "resource" ]

[ "def", "stop", "(", "self", ",", "*", "args", ",", "*", "*", "kwargs", ")", ":", "warnings", ".", "warn", "(", "\"The 'stop()' method is deprecated, please use 'remove()' instead\"", ",", "DeprecationWarning", ")", "return", "self", ".", "remove", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "Deprecated", "function", "to", "|remove|", "an", "existing", "handler", "." ]

[ "def", "name_transfer", "(", "self", ",", "key", ",", "new_address", ",", "value", "=", "None", ")", ":", "key_details", "=", "self", ".", "name_show", "(", "key", ")", "if", "'code'", "in", "key_details", "and", "key_details", ".", "get", "(", "'code'", ")", "==", "-", "4", ":", "return", "error_reply", "(", "\"Key does not exist\"", ")", "# get new 'value' if given, otherwise use the old 'value'", "if", "value", "is", "None", ":", "value", "=", "json", ".", "dumps", "(", "key_details", "[", "'value'", "]", ")", "if", "not", "self", ".", "unlock_wallet", "(", "self", ".", "passphrase", ")", ":", "error_reply", "(", "\"Error unlocking wallet\"", ",", "403", ")", "# transfer the name (underlying call is still name_update)", "try", ":", "# update the 'value'", "reply", "=", "self", ".", "obj", ".", "name_update", "(", "key", ",", "value", ",", "new_address", ")", "except", "JSONRPCException", "as", "e", ":", "return", "e", ".", "error", "return", "reply" ]

[ "Check", "if", "this", "name", "exists", "and", "if", "it", "does", "find", "the", "value", "field", "note", "that", "update", "command", "needs", "an", "arg", "of", "<new", "value", ">", ".", "in", "case", "we", "re", "simply", "transferring", "need", "to", "obtain", "old", "value", "first" ]

[ "def", "delete_post", "(", "self", ",", "post_id", ")", ":", "status", "=", "False", "success", "=", "0", "post_id", "=", "_as_int", "(", "post_id", ")", "with", "self", ".", "_engine", ".", "begin", "(", ")", "as", "conn", ":", "try", ":", "post_del_statement", "=", "self", ".", "_post_table", ".", "delete", "(", ")", ".", "where", "(", "self", ".", "_post_table", ".", "c", ".", "id", "==", "post_id", ")", "conn", ".", "execute", "(", "post_del_statement", ")", "success", "+=", "1", "except", "Exception", "as", "e", ":", "self", ".", "_logger", ".", "exception", "(", "str", "(", "e", ")", ")", "try", ":", "user_posts_del_statement", "=", "self", ".", "_user_posts_table", ".", "delete", "(", ")", ".", "where", "(", "self", ".", "_user_posts_table", ".", "c", ".", "post_id", "==", "post_id", ")", "conn", ".", "execute", "(", "user_posts_del_statement", ")", "success", "+=", "1", "except", "Exception", "as", "e", ":", "self", ".", "_logger", ".", "exception", "(", "str", "(", "e", ")", ")", "try", ":", "tag_posts_del_statement", "=", "self", ".", "_tag_posts_table", ".", "delete", "(", ")", ".", "where", "(", "self", ".", "_tag_posts_table", ".", "c", ".", "post_id", "==", "post_id", ")", "conn", ".", "execute", "(", "tag_posts_del_statement", ")", "success", "+=", "1", "except", "Exception", "as", "e", ":", "self", ".", "_logger", ".", "exception", "(", "str", "(", "e", ")", ")", "status", "=", "success", "==", "3", "return", "status" ]

[ "Delete", "the", "post", "defined", "by", "post_id" ]

[ "def", "_to_dict", "(", "self", ")", ":", "_dict", "=", "{", "}", "if", "hasattr", "(", "self", ",", "'credential_type'", ")", "and", "self", ".", "credential_type", "is", "not", "None", ":", "_dict", "[", "'credential_type'", "]", "=", "self", ".", "credential_type", "if", "hasattr", "(", "self", ",", "'client_id'", ")", "and", "self", ".", "client_id", "is", "not", "None", ":", "_dict", "[", "'client_id'", "]", "=", "self", ".", "client_id", "if", "hasattr", "(", "self", ",", "'enterprise_id'", ")", "and", "self", ".", "enterprise_id", "is", "not", "None", ":", "_dict", "[", "'enterprise_id'", "]", "=", "self", ".", "enterprise_id", "if", "hasattr", "(", "self", ",", "'url'", ")", "and", "self", ".", "url", "is", "not", "None", ":", "_dict", "[", "'url'", "]", "=", "self", ".", "url", "if", "hasattr", "(", "self", ",", "'username'", ")", "and", "self", ".", "username", "is", "not", "None", ":", "_dict", "[", "'username'", "]", "=", "self", ".", "username", "if", "hasattr", "(", "self", ",", "'organization_url'", ")", "and", "self", ".", "organization_url", "is", "not", "None", ":", "_dict", "[", "'organization_url'", "]", "=", "self", ".", "organization_url", "if", "hasattr", "(", "self", ",", "'site_collection_path'", ")", "and", "self", ".", "site_collection_path", "is", "not", "None", ":", "_dict", "[", "'site_collection.path'", "]", "=", "self", ".", "site_collection_path", "if", "hasattr", "(", "self", ",", "'client_secret'", ")", "and", "self", ".", "client_secret", "is", "not", "None", ":", "_dict", "[", "'client_secret'", "]", "=", "self", ".", "client_secret", "if", "hasattr", "(", "self", ",", "'public_key_id'", ")", "and", "self", ".", "public_key_id", "is", "not", "None", ":", "_dict", "[", "'public_key_id'", "]", "=", "self", ".", "public_key_id", "if", "hasattr", "(", "self", ",", "'private_key'", ")", "and", "self", ".", "private_key", "is", "not", "None", ":", "_dict", "[", "'private_key'", "]", "=", "self", ".", "private_key", "if", "hasattr", "(", "self", ",", "'passphrase'", ")", "and", "self", ".", "passphrase", "is", "not", "None", ":", "_dict", "[", "'passphrase'", "]", "=", "self", ".", "passphrase", "if", "hasattr", "(", "self", ",", "'password'", ")", "and", "self", ".", "password", "is", "not", "None", ":", "_dict", "[", "'password'", "]", "=", "self", ".", "password", "if", "hasattr", "(", "self", ",", "'gateway_id'", ")", "and", "self", ".", "gateway_id", "is", "not", "None", ":", "_dict", "[", "'gateway_id'", "]", "=", "self", ".", "gateway_id", "if", "hasattr", "(", "self", ",", "'source_version'", ")", "and", "self", ".", "source_version", "is", "not", "None", ":", "_dict", "[", "'source_version'", "]", "=", "self", ".", "source_version", "if", "hasattr", "(", "self", ",", "'web_application_url'", ")", "and", "self", ".", "web_application_url", "is", "not", "None", ":", "_dict", "[", "'web_application_url'", "]", "=", "self", ".", "web_application_url", "if", "hasattr", "(", "self", ",", "'domain'", ")", "and", "self", ".", "domain", "is", "not", "None", ":", "_dict", "[", "'domain'", "]", "=", "self", ".", "domain", "if", "hasattr", "(", "self", ",", "'endpoint'", ")", "and", "self", ".", "endpoint", "is", "not", "None", ":", "_dict", "[", "'endpoint'", "]", "=", "self", ".", "endpoint", "if", "hasattr", "(", "self", ",", "'access_key_id'", ")", "and", "self", ".", "access_key_id", "is", "not", "None", ":", "_dict", "[", "'access_key_id'", "]", "=", "self", ".", "access_key_id", "if", "hasattr", "(", "self", ",", "'secret_access_key'", ")", "and", "self", ".", "secret_access_key", "is", "not", "None", ":", "_dict", "[", "'secret_access_key'", "]", "=", "self", ".", "secret_access_key", "return", "_dict" ]

[ "Return", "a", "json", "dictionary", "representing", "this", "model", "." ]

[ "def", "unset_key", "(", "dotenv_path", ",", "key_to_unset", ",", "quote_mode", "=", "\"always\"", ")", ":", "if", "not", "os", ".", "path", ".", "exists", "(", "dotenv_path", ")", ":", "warnings", ".", "warn", "(", "\"can't delete from %s - it doesn't exist.\"", "%", "dotenv_path", ")", "return", "None", ",", "key_to_unset", "removed", "=", "False", "with", "rewrite", "(", "dotenv_path", ")", "as", "(", "source", ",", "dest", ")", ":", "for", "mapping", "in", "parse_stream", "(", "source", ")", ":", "if", "mapping", ".", "key", "==", "key_to_unset", ":", "removed", "=", "True", "else", ":", "dest", ".", "write", "(", "mapping", ".", "original", ")", "if", "not", "removed", ":", "warnings", ".", "warn", "(", "\"key %s not removed from %s - key doesn't exist.\"", "%", "(", "key_to_unset", ",", "dotenv_path", ")", ")", "return", "None", ",", "key_to_unset", "return", "removed", ",", "key_to_unset" ]

[ "Removes", "a", "given", "key", "from", "the", "given", ".", "env" ]

[ "def", "chained", "(", "wrapping_exc", ")", ":", "# pylint: disable=W0212", "t", ",", "v", ",", "tb", "=", "sys", ".", "exc_info", "(", ")", "if", "not", "t", ":", "return", "wrapping_exc", "wrapping_exc", ".", "_inner_exc", "=", "v", "lines", "=", "traceback", ".", "format_exception", "(", "t", ",", "v", ",", "tb", ")", "wrapping_exc", ".", "_inner_tb", "=", "\"\"", ".", "join", "(", "lines", "[", "1", ":", "]", ")", "return", "wrapping_exc" ]

[ "Embeds", "the", "current", "exception", "information", "into", "the", "given", "one", "(", "which", "will", "replace", "the", "current", "one", ")", ".", "For", "example", "::" ]

[ "def", "archive_context", "(", "filename", ")", ":", "tmpdir", "=", "tempfile", ".", "mkdtemp", "(", ")", "log", ".", "warn", "(", "'Extracting in %s'", ",", "tmpdir", ")", "old_wd", "=", "os", ".", "getcwd", "(", ")", "try", ":", "os", ".", "chdir", "(", "tmpdir", ")", "try", ":", "with", "ContextualZipFile", "(", "filename", ")", "as", "archive", ":", "archive", ".", "extractall", "(", ")", "except", "zipfile", ".", "BadZipfile", "as", "err", ":", "if", "not", "err", ".", "args", ":", "err", ".", "args", "=", "(", "''", ",", ")", "err", ".", "args", "=", "err", ".", "args", "+", "(", "MEANINGFUL_INVALID_ZIP_ERR_MSG", ".", "format", "(", "filename", ")", ",", ")", "raise", "# going in the directory", "subdir", "=", "os", ".", "path", ".", "join", "(", "tmpdir", ",", "os", ".", "listdir", "(", "tmpdir", ")", "[", "0", "]", ")", "os", ".", "chdir", "(", "subdir", ")", "log", ".", "warn", "(", "'Now working in %s'", ",", "subdir", ")", "yield", "finally", ":", "os", ".", "chdir", "(", "old_wd", ")", "shutil", ".", "rmtree", "(", "tmpdir", ")" ]

[ "Unzip", "filename", "to", "a", "temporary", "directory", "set", "to", "the", "cwd", "." ]

[ "def", "publish_metric", "(", "self", ",", "metric_name", ",", "metric_value", ",", "epoch_seconds", "=", "None", ")", ":", "if", "epoch_seconds", "is", "None", ":", "epoch_seconds", "=", "self", ".", "_reactor", ".", "seconds", "(", ")", "self", ".", "_client_factory", ".", "publish_metric", "(", "metric_name", ",", "metric_value", ",", "int", "(", "epoch_seconds", ")", ")" ]

[ "Record", "a", "single", "hit", "on", "a", "given", "metric", "." ]

[ "def", "softmax_cross_entropy_with_logits", "(", "logits", ",", "targets", ",", "vocab_dim", ",", "z_loss", "=", "0.0", ")", ":", "if", "logits", ".", "shape", "!=", "targets", ".", "shape", ":", "raise", "ValueError", "(", "\"logits shape must equal targets shape\"", "\"logits=%s targets=%s\"", "%", "(", "logits", ".", "to_string", ",", "targets", ".", "to_string", ")", ")", "if", "vocab_dim", "not", "in", "logits", ".", "shape", ".", "dims", ":", "raise", "ValueError", "(", "\"vocab_dim must be in logits.shape.dims\"", ")", "log_z", "=", "mtf", ".", "reduce_logsumexp", "(", "logits", ",", "vocab_dim", ")", "log_softmax", "=", "logits", "-", "log_z", "loss", "=", "mtf", ".", "negative", "(", "mtf", ".", "reduce_sum", "(", "log_softmax", "*", "targets", ",", "reduced_dim", "=", "vocab_dim", ")", ")", "if", "z_loss", "!=", "0", ":", "loss", "+=", "z_loss", "*", "mtf", ".", "square", "(", "log_z", ")", "return", "loss" ]

[ "Per", "-", "example", "softmax", "loss", "." ]

[ "def", "update", "(", "*", "args", ",", "*", "*", "kwds", ")", ":", "# The regular dict.update() operation makes no sense here because the", "# replace behavior results in the some of original untouched counts", "# being mixed-in with all of the other counts for a mismash that", "# doesn't have a straight-forward interpretation in most counting", "# contexts. Instead, we implement straight-addition. Both the inputs", "# and outputs are allowed to contain zero and negative counts.", "if", "not", "args", ":", "raise", "TypeError", "(", "\"descriptor 'update' of 'Counter' object \"", "\"needs an argument\"", ")", "self", "=", "args", "[", "0", "]", "args", "=", "args", "[", "1", ":", "]", "if", "len", "(", "args", ")", ">", "1", ":", "raise", "TypeError", "(", "'expected at most 1 arguments, got %d'", "%", "len", "(", "args", ")", ")", "iterable", "=", "args", "[", "0", "]", "if", "args", "else", "None", "if", "iterable", "is", "not", "None", ":", "if", "isinstance", "(", "iterable", ",", "Mapping", ")", ":", "if", "self", ":", "self_get", "=", "self", ".", "get", "for", "elem", ",", "count", "in", "iterable", ".", "iteritems", "(", ")", ":", "self", "[", "elem", "]", "=", "self_get", "(", "elem", ",", "0", ")", "+", "count", "else", ":", "super", "(", "Counter", ",", "self", ")", ".", "update", "(", "iterable", ")", "# fast path when counter is empty", "else", ":", "self_get", "=", "self", ".", "get", "for", "elem", "in", "iterable", ":", "self", "[", "elem", "]", "=", "self_get", "(", "elem", ",", "0", ")", "+", "1", "if", "kwds", ":", "self", ".", "update", "(", "kwds", ")" ]

[ "Like", "dict", ".", "update", "()", "but", "add", "counts", "instead", "of", "replacing", "them", "." ]

[ "def", "_lookup_version", "(", "module_file", ")", ":", "version_dir", "=", "path", ".", "abspath", "(", "path", ".", "dirname", "(", "module_file", ")", ")", "version_file", "=", "path", ".", "join", "(", "version_dir", ",", "\"RELEASE-VERSION\"", ")", "return", "version_dir", ",", "version_file" ]

[ "For", "the", "given", "module", "file", "(", "usually", "found", "by", ":" ]

[ "def", "to_jd", "(", "year", ",", "month", ",", "day", ",", "method", "=", "None", ")", ":", "method", "=", "method", "or", "'equinox'", "if", "day", "<", "1", "or", "day", ">", "30", ":", "raise", "ValueError", "(", "\"Invalid day for this calendar\"", ")", "if", "month", ">", "13", ":", "raise", "ValueError", "(", "\"Invalid month for this calendar\"", ")", "if", "month", "==", "13", "and", "day", ">", "5", "+", "leap", "(", "year", ",", "method", "=", "method", ")", ":", "raise", "ValueError", "(", "\"Invalid day for this month in this calendar\"", ")", "if", "method", "==", "'equinox'", ":", "return", "_to_jd_equinox", "(", "year", ",", "month", ",", "day", ")", "else", ":", "return", "_to_jd_schematic", "(", "year", ",", "month", ",", "day", ",", "method", ")" ]

[ "Obtain", "Julian", "day", "from", "a", "given", "French", "Revolutionary", "calendar", "date", "." ]

[ "def", "reverseCommit", "(", "self", ")", ":", "# Move the cursor to the right of the text to delete.", "tc", "=", "self", ".", "qteWidget", ".", "textCursor", "(", ")", "# Delete as many characters as necessary. For an image that would", "# be exactly 1 even though the HTML code to embed that image is usually", "# longer. For text, it would be as many characters as the pasted text", "# was long.", "if", "self", ".", "isImage", ":", "dataLen", "=", "1", "else", ":", "dataLen", "=", "len", "(", "self", ".", "data", ")", "tc", ".", "setPosition", "(", "self", ".", "selStart", "+", "dataLen", ",", "QtGui", ".", "QTextCursor", ".", "MoveAnchor", ")", "for", "ii", "in", "range", "(", "dataLen", ")", ":", "tc", ".", "deletePreviousChar", "(", ")", "# Add the previously selected text (this may be none).", "tc", ".", "insertHtml", "(", "self", ".", "selText", ")", "self", ".", "qteWidget", ".", "setTextCursor", "(", "tc", ")" ]

[ "Remove", "the", "inserted", "character", "(", "s", ")", "." ]

[ "def", "subvol_create", "(", "self", ",", "path", ")", ":", "args", "=", "{", "'path'", ":", "path", "}", "self", ".", "_subvol_chk", ".", "check", "(", "args", ")", "self", ".", "_client", ".", "sync", "(", "'btrfs.subvol_create'", ",", "args", ")" ]

[ "Create", "a", "btrfs", "subvolume", "in", "the", "specified", "path", ":", "param", "path", ":", "path", "to", "create" ]

[ "def", "raise_exception", "(", "self", ",", "exception", ")", ":", "self", ".", "__data", "=", "None", "self", ".", "__exception", "=", "exception", "self", ".", "__event", ".", "set", "(", ")" ]

[ "Raises", "an", "exception", "in", "wait", "()" ]

[ "def", "get_common_session_key", "(", "self", ",", "premaster_secret", ")", ":", "k_1", "=", "self", ".", "hash", "(", "premaster_secret", ",", "b'\\x00\\x00\\x00\\x00'", ",", "as_bytes", "=", "True", ")", "k_2", "=", "self", ".", "hash", "(", "premaster_secret", ",", "b'\\x00\\x00\\x00\\x01'", ",", "as_bytes", "=", "True", ")", "return", "k_1", "+", "k_2" ]

[ "K", "=", "H", "(", "S", ")", "." ]

[ "def", "can_solve", "(", "cls", ",", "resource", ")", ":", "for", "solvable_resource", "in", "cls", ".", "solvable_resources", ":", "if", "isinstance", "(", "resource", ",", "solvable_resource", ")", ":", "return", "True", "return", "False" ]

[ "Tells", "if", "the", "solver", "is", "able", "to", "resolve", "the", "given", "resource", "." ]

[ "def", "_validate_range", "(", "self", ",", "max_", ",", "min_", ",", "max_ex", ",", "min_ex", ",", "value", ",", "path", ",", "prefix", ")", ":", "if", "not", "isinstance", "(", "value", ",", "int", ")", "and", "not", "isinstance", "(", "value", ",", "float", ")", ":", "raise", "CoreError", "(", "\"Value must be a integer type\"", ")", "log", ".", "debug", "(", "u\"Validate range : %s : %s : %s : %s : %s : %s\"", ",", "max_", ",", "min_", ",", "max_ex", ",", "min_ex", ",", "value", ",", "path", ",", ")", "if", "max_", "is", "not", "None", "and", "max_", "<", "value", ":", "self", ".", "errors", ".", "append", "(", "SchemaError", ".", "SchemaErrorEntry", "(", "msg", "=", "u\"Type '{prefix}' has size of '{value}', greater than max limit '{max_}'. Path: '{path}'\"", ",", "path", "=", "path", ",", "value", "=", "nativestr", "(", "value", ")", "if", "tt", "[", "'str'", "]", "(", "value", ")", "else", "value", ",", "prefix", "=", "prefix", ",", "max_", "=", "max_", ")", ")", "if", "min_", "is", "not", "None", "and", "min_", ">", "value", ":", "self", ".", "errors", ".", "append", "(", "SchemaError", ".", "SchemaErrorEntry", "(", "msg", "=", "u\"Type '{prefix}' has size of '{value}', less than min limit '{min_}'. Path: '{path}'\"", ",", "path", "=", "path", ",", "value", "=", "nativestr", "(", "value", ")", "if", "tt", "[", "'str'", "]", "(", "value", ")", "else", "value", ",", "prefix", "=", "prefix", ",", "min_", "=", "min_", ")", ")", "if", "max_ex", "is", "not", "None", "and", "max_ex", "<=", "value", ":", "self", ".", "errors", ".", "append", "(", "SchemaError", ".", "SchemaErrorEntry", "(", "msg", "=", "u\"Type '{prefix}' has size of '{value}', greater than or equals to max limit(exclusive) '{max_ex}'. Path: '{path}'\"", ",", "path", "=", "path", ",", "value", "=", "nativestr", "(", "value", ")", "if", "tt", "[", "'str'", "]", "(", "value", ")", "else", "value", ",", "prefix", "=", "prefix", ",", "max_ex", "=", "max_ex", ")", ")", "if", "min_ex", "is", "not", "None", "and", "min_ex", ">=", "value", ":", "self", ".", "errors", ".", "append", "(", "SchemaError", ".", "SchemaErrorEntry", "(", "msg", "=", "u\"Type '{prefix}' has size of '{value}', less than or equals to min limit(exclusive) '{min_ex}'. Path: '{path}'\"", ",", "path", "=", "path", ",", "value", "=", "nativestr", "(", "value", ")", "if", "tt", "[", "'str'", "]", "(", "value", ")", "else", "value", ",", "prefix", "=", "prefix", ",", "min_ex", "=", "min_ex", ")", ")" ]

[ "Validate", "that", "value", "is", "within", "range", "values", "." ]

[ "def", "flatten_list", "(", "multiply_list", ")", ":", "if", "isinstance", "(", "multiply_list", ",", "list", ")", ":", "return", "[", "rv", "for", "l", "in", "multiply_list", "for", "rv", "in", "flatten_list", "(", "l", ")", "]", "else", ":", "return", "[", "multiply_list", "]" ]

[ "碾平", "list", "::" ]

[ "def", "setSizeHint", "(", "self", ",", "column", ",", "hint", ")", ":", "self", ".", "_fixedHeight", "=", "max", "(", "hint", ".", "height", "(", ")", ",", "self", ".", "_fixedHeight", ")", "super", "(", "XTreeWidgetItem", ",", "self", ")", ".", "setSizeHint", "(", "column", ",", "hint", ")" ]

[ "Sets", "the", "size", "hint", "for", "this", "item", "to", "the", "inputed", "size", ".", "This", "will", "also", "updated", "the", "fixed", "height", "property", "if", "the", "hieght", "of", "the", "inputed", "hint", "is", "larger", "than", "the", "current", "fixed", "height", ".", ":", "param", "hint", "|", "<QtCore", ".", "QSize", ">" ]

[ "def", "on_unselect", "(", "self", ",", "item", ",", "action", ")", ":", "if", "not", "isinstance", "(", "item", ",", "int", ")", ":", "item", "=", "self", ".", "items", ".", "index", "(", "item", ")", "self", ".", "_on_unselect", "[", "item", "]", "=", "action" ]

[ "Add", "an", "action", "to", "make", "when", "an", "object", "is", "unfocused", "." ]

[ "def", "compute_displays_sweep", "(", "self", ",", "program", ":", "Union", "[", "circuits", ".", "Circuit", ",", "schedules", ".", "Schedule", "]", ",", "params", ":", "Optional", "[", "study", ".", "Sweepable", "]", "=", "None", ",", "qubit_order", ":", "ops", ".", "QubitOrderOrList", "=", "ops", ".", "QubitOrder", ".", "DEFAULT", ",", "initial_state", ":", "Union", "[", "int", ",", "np", ".", "ndarray", "]", "=", "0", ",", ")", "->", "List", "[", "study", ".", "ComputeDisplaysResult", "]", ":", "circuit", "=", "(", "program", "if", "isinstance", "(", "program", ",", "circuits", ".", "Circuit", ")", "else", "program", ".", "to_circuit", "(", ")", ")", "param_resolvers", "=", "study", ".", "to_resolvers", "(", "params", "or", "study", ".", "ParamResolver", "(", "{", "}", ")", ")", "qubit_order", "=", "ops", ".", "QubitOrder", ".", "as_qubit_order", "(", "qubit_order", ")", "qubits", "=", "qubit_order", ".", "order_for", "(", "circuit", ".", "all_qubits", "(", ")", ")", "compute_displays_results", "=", "[", "]", "# type: List[study.ComputeDisplaysResult]", "for", "param_resolver", "in", "param_resolvers", ":", "display_values", "=", "{", "}", "# type: Dict[Hashable, Any]", "# Compute the displays in the first Moment", "moment", "=", "circuit", "[", "0", "]", "matrix", "=", "density_matrix_utils", ".", "to_valid_density_matrix", "(", "initial_state", ",", "num_qubits", "=", "len", "(", "qubits", ")", ",", "dtype", "=", "self", ".", "_dtype", ")", "qubit_map", "=", "{", "q", ":", "i", "for", "i", ",", "q", "in", "enumerate", "(", "qubits", ")", "}", "_enter_moment_display_values_into_dictionary", "(", "display_values", ",", "moment", ",", "matrix", ",", "qubit_order", ",", "qubit_map", ")", "# Compute the displays in the rest of the Moments", "all_step_results", "=", "self", ".", "simulate_moment_steps", "(", "circuit", ",", "param_resolver", ",", "qubit_order", ",", "initial_state", ")", "for", "step_result", ",", "moment", "in", "zip", "(", "all_step_results", ",", "circuit", "[", "1", ":", "]", ")", ":", "_enter_moment_display_values_into_dictionary", "(", "display_values", ",", "moment", ",", "step_result", ".", "density_matrix", "(", ")", ",", "qubit_order", ",", "step_result", ".", "_qubit_map", ")", "compute_displays_results", ".", "append", "(", "study", ".", "ComputeDisplaysResult", "(", "params", "=", "param_resolver", ",", "display_values", "=", "display_values", ")", ")", "return", "compute_displays_results" ]

[ "Computes", "displays", "in", "the", "supplied", "Circuit", "or", "Schedule", "." ]

[ "def", "get_default_config_help", "(", "self", ")", ":", "config", "=", "super", "(", "GraphitePickleHandler", ",", "self", ")", ".", "get_default_config_help", "(", ")", "config", ".", "update", "(", "{", "}", ")", "return", "config" ]

[ "Returns", "the", "help", "text", "for", "the", "configuration", "options", "for", "this", "handler" ]

[ "def", "get_raw_history", "(", "self", ",", "item", "=", "None", ",", "nb", "=", "0", ")", ":", "s", "=", "self", ".", "stats_history", ".", "get", "(", "nb", "=", "nb", ")", "if", "item", "is", "None", ":", "return", "s", "else", ":", "if", "item", "in", "s", ":", "return", "s", "[", "item", "]", "else", ":", "return", "None" ]

[ "Return", "the", "history", "(", "RAW", "format", ")", "." ]

[ "def", "euler_tour", "(", "G", ",", "node", "=", "None", ",", "seen", "=", "None", ",", "visited", "=", "None", ")", ":", "if", "node", "is", "None", ":", "node", "=", "next", "(", "G", ".", "nodes", "(", ")", ")", "if", "visited", "is", "None", ":", "assert", "nx", ".", "is_tree", "(", "G", ")", "visited", "=", "[", "]", "if", "seen", "is", "None", ":", "seen", "=", "set", "(", "[", "]", ")", "visited", ".", "append", "(", "node", ")", "for", "c", "in", "G", ".", "neighbors", "(", "node", ")", ":", "if", "c", "in", "seen", ":", "continue", "seen", ".", "add", "(", "c", ")", "euler_tour", "(", "G", ",", "c", ",", "seen", ",", "visited", ")", "visited", ".", "append", "(", "node", ")", "return", "visited" ]

[ "definition", "from", "http", ":", "//", "citeseerx", ".", "ist", ".", "psu", ".", "edu", "/", "viewdoc", "/", "download?doi", "=", "10", ".", "1", ".", "1", ".", "192", ".", "8615&rep", "=", "rep1&type", "=", "pdf" ]

[ "def", "copychildren", "(", "self", ",", "newdoc", "=", "None", ",", "idsuffix", "=", "\"\"", ")", ":", "if", "idsuffix", "is", "True", ":", "idsuffix", "=", "\".copy.\"", "+", "\"%08x\"", "%", "random", ".", "getrandbits", "(", "32", ")", "#random 32-bit hash for each copy, same one will be reused for all children", "for", "c", "in", "self", ":", "if", "isinstance", "(", "c", ",", "Word", ")", ":", "yield", "WordReference", "(", "newdoc", ",", "id", "=", "c", ".", "id", ")", "else", ":", "yield", "c", ".", "copy", "(", "newdoc", ",", "idsuffix", ")" ]

[ "Generator", "creating", "a", "deep", "copy", "of", "the", "children", "of", "this", "element", ".", "If", "idsuffix", "is", "a", "string", "if", "set", "to", "True", "a", "random", "idsuffix", "will", "be", "generated", "including", "a", "random", "32", "-", "bit", "hash" ]

[ "async", "def", "_start", "(", "self", ")", ":", "self", ".", "agent", ".", "_alive", ".", "wait", "(", ")", "try", ":", "await", "self", ".", "on_start", "(", ")", "except", "Exception", "as", "e", ":", "logger", ".", "error", "(", "\"Exception running on_start in behaviour {}: {}\"", ".", "format", "(", "self", ",", "e", ")", ")", "self", ".", "kill", "(", "exit_code", "=", "e", ")", "await", "self", ".", "_step", "(", ")", "self", ".", "_is_done", ".", "clear", "(", ")" ]

[ "Start", "coroutine", ".", "runs", "on_start", "coroutine", "and", "then", "runs", "the", "_step", "coroutine", "where", "the", "body", "of", "the", "behaviour", "is", "called", "." ]

[ "def", "future", "(", "self", ",", "in_days", "=", "None", ",", "in_hours", "=", "None", ",", "in_minutes", "=", "None", ",", "in_seconds", "=", "None", ")", ":", "future", "=", "None", "# Initialize variables to 0", "dd", ",", "hh", ",", "mm", ",", "ss", "=", "[", "0", "for", "i", "in", "range", "(", "4", ")", "]", "if", "(", "in_days", "!=", "None", ")", ":", "dd", "=", "dd", "+", "in_days", "if", "(", "in_hours", "!=", "None", ")", ":", "hh", "=", "hh", "+", "in_hours", "if", "(", "in_minutes", "!=", "None", ")", ":", "mm", "=", "mm", "+", "in_minutes", "if", "(", "in_seconds", "!=", "None", ")", ":", "ss", "=", "ss", "+", "in_seconds", "# Set the hours, minutes and seconds from now (minus the days)", "dnow", "=", "datetime", ".", "datetime", ".", "utcnow", "(", ")", "# Now", "d", "=", "dnow", "+", "datetime", ".", "timedelta", "(", "hours", "=", "hh", ",", "minutes", "=", "mm", ",", "seconds", "=", "ss", ")", "# Time from midnight", "for_total_seconds", "=", "d", "-", "d", ".", "replace", "(", "hour", "=", "0", ",", "minute", "=", "0", ",", "second", "=", "0", ",", "microsecond", "=", "0", ")", "# Convert into minutes since midnight", "try", ":", "msm", "=", "for_total_seconds", ".", "total_seconds", "(", ")", "/", "60.", "except", ":", "# For versions before 2.7", "msm", "=", "self", ".", "timedelta_total_seconds", "(", "for_total_seconds", ")", "/", "60.", "if", "(", "dd", "<", "len", "(", "self", ".", "days", ")", ")", ":", "for", "timestep", "in", "self", ".", "days", "[", "dd", "]", ".", "timesteps", ":", "if", "timestep", ".", "name", ">=", "msm", ":", "future", "=", "timestep", "return", "future", "else", ":", "print", "(", "'ERROR: requested date is outside the forecast range selected,'", "+", "str", "(", "len", "(", "self", ".", "days", ")", ")", ")", "return", "False" ]

[ "Function", "to", "return", "a", "future", "timestep" ]

[ "def", "safe_unicode", "(", "value", ")", ":", "if", "sys", ".", "version_info", "<", "(", "3", ",", "0", ")", ":", "if", "isinstance", "(", "value", ",", "str", ")", ":", "return", "value", ".", "decode", "(", "'utf-8'", ")", "else", ":", "return", "unicode", "(", "value", ")", "else", ":", "return", "str", "(", "value", ")" ]

[ "Returns", ":" ]

[ "def", "_check_path", "(", "self", ",", "src", ",", "path_type", ",", "dest", "=", "None", ",", "force", "=", "False", ")", ":", "dest", "=", "dest", "or", "self", ".", "dest_path", "(", "src", ")", "if", "path_type", "==", "P_DIR", ":", "dest_dir", "=", "dest", "else", ":", "dest_dir", "=", "os", ".", "path", ".", "split", "(", "dest", ")", "[", "0", "]", "if", "not", "dest_dir", ":", "return", "dest", "# Check containing directory presence and path type", "if", "os", ".", "path", ".", "exists", "(", "dest_dir", ")", "and", "not", "os", ".", "path", ".", "isdir", "(", "dest_dir", ")", ":", "raise", "ValueError", "(", "\"path '%s' exists and is not a directory\"", "%", "dest_dir", ")", "elif", "not", "os", ".", "path", ".", "exists", "(", "dest_dir", ")", ":", "src_dir", "=", "src", "if", "path_type", "==", "P_DIR", "else", "os", ".", "path", ".", "split", "(", "src", ")", "[", "0", "]", "self", ".", "_make_leading_paths", "(", "src_dir", ")", "def", "is_special", "(", "mode", ")", ":", "return", "any", "(", "[", "stat", ".", "S_ISBLK", "(", "mode", ")", ",", "stat", ".", "S_ISCHR", "(", "mode", ")", ",", "stat", ".", "S_ISFIFO", "(", "mode", ")", ",", "stat", ".", "S_ISSOCK", "(", "mode", ")", "]", ")", "if", "force", ":", "return", "dest", "# Check destination path presence and type", "if", "os", ".", "path", ".", "exists", "(", "dest", ")", ":", "# Use lstat: we care about the current object, not the referent.", "st", "=", "os", ".", "lstat", "(", "dest", ")", "ve_msg", "=", "\"path '%s' exists and is not a %s\"", "if", "path_type", "==", "P_FILE", "and", "not", "stat", ".", "S_ISREG", "(", "st", ".", "st_mode", ")", ":", "raise", "ValueError", "(", "ve_msg", "%", "(", "dest", ",", "\"regular file\"", ")", ")", "if", "path_type", "==", "P_LINK", "and", "not", "stat", ".", "S_ISLNK", "(", "st", ".", "st_mode", ")", ":", "raise", "ValueError", "(", "ve_msg", "%", "(", "dest", ",", "\"symbolic link\"", ")", ")", "if", "path_type", "==", "P_NODE", "and", "not", "is_special", "(", "st", ".", "st_mode", ")", ":", "raise", "ValueError", "(", "ve_msg", "%", "(", "dest", ",", "\"special file\"", ")", ")", "if", "path_type", "==", "P_DIR", "and", "not", "stat", ".", "S_ISDIR", "(", "st", ".", "st_mode", ")", ":", "raise", "ValueError", "(", "ve_msg", "%", "(", "dest", ",", "\"directory\"", ")", ")", "# Path has already been copied: skip", "return", "None", "return", "dest" ]

[ "Check", "a", "new", "destination", "path", "in", "the", "archive", "." ]

[ "def", "replaceMaskedValueWithNan", "(", "self", ")", ":", "kind", "=", "self", ".", "data", ".", "dtype", ".", "kind", "if", "kind", "==", "'i'", "or", "kind", "==", "'u'", ":", "# signed/unsigned int", "self", ".", "data", "=", "self", ".", "data", ".", "astype", "(", "np", ".", "float", ",", "casting", "=", "'safe'", ")", "if", "self", ".", "data", ".", "dtype", ".", "kind", "!=", "'f'", ":", "return", "# only replace for floats", "if", "self", ".", "mask", "is", "False", ":", "pass", "elif", "self", ".", "mask", "is", "True", ":", "self", ".", "data", "[", ":", "]", "=", "np", ".", "NaN", "else", ":", "self", ".", "data", "[", "self", ".", "mask", "]", "=", "np", ".", "NaN" ]

[ "Replaces", "values", "where", "the", "mask", "is", "True", "with", "the", "replacement", "value", "." ]

[ "def", "store", "(", "config", ",", "archiver", ",", "revision", ",", "stats", ")", ":", "root", "=", "pathlib", ".", "Path", "(", "config", ".", "cache_path", ")", "/", "archiver", ".", "name", "if", "not", "root", ".", "exists", "(", ")", ":", "logger", ".", "debug", "(", "\"Creating wily cache\"", ")", "root", ".", "mkdir", "(", ")", "# fix absolute path references.", "if", "config", ".", "path", "!=", "\".\"", ":", "for", "operator", ",", "operator_data", "in", "list", "(", "stats", "[", "\"operator_data\"", "]", ".", "items", "(", ")", ")", ":", "if", "operator_data", ":", "new_operator_data", "=", "operator_data", ".", "copy", "(", ")", "for", "k", ",", "v", "in", "list", "(", "operator_data", ".", "items", "(", ")", ")", ":", "new_key", "=", "os", ".", "path", ".", "relpath", "(", "str", "(", "k", ")", ",", "str", "(", "config", ".", "path", ")", ")", "del", "new_operator_data", "[", "k", "]", "new_operator_data", "[", "new_key", "]", "=", "v", "del", "stats", "[", "\"operator_data\"", "]", "[", "operator", "]", "stats", "[", "\"operator_data\"", "]", "[", "operator", "]", "=", "new_operator_data", "logger", ".", "debug", "(", "f\"Creating {revision.key} output\"", ")", "filename", "=", "root", "/", "(", "revision", ".", "key", "+", "\".json\"", ")", "if", "filename", ".", "exists", "(", ")", ":", "raise", "RuntimeError", "(", "f\"File {filename} already exists, index may be corrupt.\"", ")", "with", "open", "(", "filename", ",", "\"w\"", ")", "as", "out", ":", "out", ".", "write", "(", "json", ".", "dumps", "(", "stats", ",", "indent", "=", "2", ")", ")", "return", "filename" ]

[ "Store", "a", "revision", "record", "within", "an", "archiver", "folder", "." ]

[ "def", "check_and_adjust_sighandlers", "(", "self", ")", ":", "for", "signame", "in", "list", "(", "self", ".", "sigs", ".", "keys", "(", ")", ")", ":", "if", "not", "self", ".", "check_and_adjust_sighandler", "(", "signame", ",", "self", ".", "sigs", ")", ":", "break", "pass", "return" ]

[ "Check", "to", "see", "if", "any", "of", "the", "signal", "handlers", "we", "are", "interested", "in", "have", "changed", "or", "is", "not", "initially", "set", ".", "Change", "any", "that", "are", "not", "right", "." ]

[ "def", "_uptime_plan9", "(", ")", ":", "# Apparently Plan 9 only has Python 2.2, which I'm not prepared to", "# support. Maybe some Linuxes implement /dev/time, though, someone was", "# talking about it somewhere.", "try", ":", "# The time file holds one 32-bit number representing the sec-", "# onds since start of epoch and three 64-bit numbers, repre-", "# senting nanoseconds since start of epoch, clock ticks, and", "# clock frequency.", "# -- cons(3)", "f", "=", "open", "(", "'/dev/time'", ",", "'r'", ")", "s", ",", "ns", ",", "ct", ",", "cf", "=", "f", ".", "read", "(", ")", ".", "split", "(", ")", "f", ".", "close", "(", ")", "return", "float", "(", "ct", ")", "/", "float", "(", "cf", ")", "except", "(", "IOError", ",", "ValueError", ")", ":", "return", "None" ]

[ "Returns", "uptime", "in", "seconds", "or", "None", "on", "Plan", "9", "." ]

[ "def", "compute_bayes_cone", "(", "preds", ",", "starting_value", "=", "1.", ")", ":", "def", "scoreatpercentile", "(", "cum_preds", ",", "p", ")", ":", "return", "[", "stats", ".", "scoreatpercentile", "(", "c", ",", "p", ")", "for", "c", "in", "cum_preds", ".", "T", "]", "cum_preds", "=", "np", ".", "cumprod", "(", "preds", "+", "1", ",", "1", ")", "*", "starting_value", "perc", "=", "{", "p", ":", "scoreatpercentile", "(", "cum_preds", ",", "p", ")", "for", "p", "in", "(", "5", ",", "25", ",", "75", ",", "95", ")", "}", "return", "perc" ]

[ "Compute", "5", "25", "75", "and", "95", "percentiles", "of", "cumulative", "returns", "used", "for", "the", "Bayesian", "cone", "." ]

[ "def", "normalize", "(", "text", ",", "mode", "=", "'NFKC'", ",", "ignore", "=", "''", ")", ":", "text", "=", "text", ".", "replace", "(", "u'〜', ", "u", "ー').re", "p", "l", "ace(u'～", "'", ", u'ー'", ")", "", "", "text", "=", "text", ".", "replace", "(", "u\"’\", ", "\"", "\").", "r", "e", "place(u", "'", "”', '\"", "'", ".re", "p", "l", "ace(u'“", "'", ", '``'", ")", "", "", "text", "=", "text", ".", "replace", "(", "u'―', ", "'", "').", "r", "e", "place(u", "'", "‐', u'", "-", ")", "", "return", "unicodedata", ".", "normalize", "(", "mode", ",", "text", ")" ]

[ "u", "Convert", "Half", "-", "width", "(", "Hankaku", ")", "Katakana", "to", "Full", "-", "width", "(", "Zenkaku", ")", "Katakana", "Full", "-", "width", "(", "Zenkaku", ")", "ASCII", "and", "DIGIT", "to", "Half", "-", "width", "(", "Hankaku", ")", "ASCII", "and", "DIGIT", ".", "Additionally", "Full", "-", "width", "wave", "dash", "(", "〜", ")", "etc", ".", "are", "normalized" ]

[ "def", "_put_policy_set", "(", "self", ",", "policy_set_id", ",", "body", ")", ":", "assert", "isinstance", "(", "body", ",", "(", "dict", ")", ")", ",", "\"PUT requires body to be a dict.\"", "uri", "=", "self", ".", "_get_policy_set_uri", "(", "guid", "=", "policy_set_id", ")", "return", "self", ".", "service", ".", "_put", "(", "uri", ",", "body", ")" ]

[ "Will", "create", "or", "update", "a", "policy", "set", "for", "the", "given", "path", "." ]

[ "def", "simulated_quantize", "(", "x", ",", "num_bits", ",", "noise", ")", ":", "shape", "=", "x", ".", "get_shape", "(", ")", ".", "as_list", "(", ")", "if", "not", "(", "len", "(", "shape", ")", ">=", "2", "and", "shape", "[", "-", "1", "]", ">", "1", ")", ":", "return", "x", "max_abs", "=", "tf", ".", "reduce_max", "(", "tf", ".", "abs", "(", "x", ")", ",", "-", "1", ",", "keepdims", "=", "True", ")", "+", "1e-9", "max_int", "=", "2", "**", "(", "num_bits", "-", "1", ")", "-", "1", "scale", "=", "max_abs", "/", "max_int", "x", "/=", "scale", "x", "=", "tf", ".", "floor", "(", "x", "+", "noise", ")", "# dequantize before storing (since this is a simulation)", "x", "*=", "scale", "return", "x" ]

[ "Simulate", "quantization", "to", "num_bits", "bits", "with", "externally", "-", "stored", "scale", "." ]

[ "def", "distance_wei_floyd", "(", "adjacency", ",", "transform", "=", "None", ")", ":", "if", "transform", "is", "not", "None", ":", "if", "transform", "==", "'log'", ":", "if", "np", ".", "logical_or", "(", "adjacency", ">", "1", ",", "adjacency", "<", "0", ")", ".", "any", "(", ")", ":", "raise", "ValueError", "(", "\"Connection strengths must be in the \"", "+", "\"interval [0,1) to use the transform \"", "+", "\"-log(w_ij).\"", ")", "SPL", "=", "-", "np", ".", "log", "(", "adjacency", ")", "elif", "transform", "==", "'inv'", ":", "SPL", "=", "1.", "/", "adjacency", "else", ":", "raise", "ValueError", "(", "\"Unexpected transform type. Only 'log' and \"", "+", "\"'inv' are accepted\"", ")", "else", ":", "SPL", "=", "adjacency", ".", "copy", "(", ")", ".", "astype", "(", "'float'", ")", "SPL", "[", "SPL", "==", "0", "]", "=", "np", ".", "inf", "n", "=", "adjacency", ".", "shape", "[", "1", "]", "flag_find_paths", "=", "True", "hops", "=", "np", ".", "array", "(", "adjacency", "!=", "0", ")", ".", "astype", "(", "'float'", ")", "Pmat", "=", "np", ".", "repeat", "(", "np", ".", "atleast_2d", "(", "np", ".", "arange", "(", "0", ",", "n", ")", ")", ",", "n", ",", "0", ")", "for", "k", "in", "range", "(", "n", ")", ":", "i2k_k2j", "=", "np", ".", "repeat", "(", "SPL", "[", ":", ",", "[", "k", "]", "]", ",", "n", ",", "1", ")", "+", "np", ".", "repeat", "(", "SPL", "[", "[", "k", "]", ",", ":", "]", ",", "n", ",", "0", ")", "if", "flag_find_paths", ":", "path", "=", "SPL", ">", "i2k_k2j", "i", ",", "j", "=", "np", ".", "where", "(", "path", ")", "hops", "[", "path", "]", "=", "hops", "[", "i", ",", "k", "]", "+", "hops", "[", "k", ",", "j", "]", "Pmat", "[", "path", "]", "=", "Pmat", "[", "i", ",", "k", "]", "SPL", "=", "np", ".", "min", "(", "np", ".", "stack", "(", "[", "SPL", ",", "i2k_k2j", "]", ",", "2", ")", ",", "2", ")", "I", "=", "np", ".", "eye", "(", "n", ")", ">", "0", "SPL", "[", "I", "]", "=", "0", "if", "flag_find_paths", ":", "hops", "[", "I", "]", ",", "Pmat", "[", "I", "]", "=", "0", ",", "0", "return", "SPL", ",", "hops", ",", "Pmat" ]

[ "Computes", "the", "topological", "length", "of", "the", "shortest", "possible", "path", "connecting", "every", "pair", "of", "nodes", "in", "the", "network", "." ]

[ "def", "write_Composition", "(", "composition", ",", "filename", ",", "zip", "=", "False", ")", ":", "text", "=", "from_Composition", "(", "composition", ")", "if", "not", "zip", ":", "f", "=", "open", "(", "filename", "+", "'.xml'", ",", "'w'", ")", "f", ".", "write", "(", "text", ")", "f", ".", "close", "(", ")", "else", ":", "import", "zipfile", "import", "os", "zf", "=", "zipfile", ".", "ZipFile", "(", "filename", "+", "'.mxl'", ",", "mode", "=", "'w'", ",", "compression", "=", "zipfile", ".", "ZIP_DEFLATED", ")", "zi", "=", "zipfile", ".", "ZipInfo", "(", "'META-INF'", "+", "os", ".", "sep", "+", "'container.xml'", ")", "zi", ".", "external_attr", "=", "0660", "<<", "16L", "zf", ".", "writestr", "(", "zi", ",", "\"<?xml version='1.0' encoding='UTF-8'?>\"", "\"<container><rootfiles><rootfile full-path='{0}.xml'/>\"", "\"</rootfiles></container>\"", ".", "format", "(", "filename", ")", ")", "zi", "=", "zipfile", ".", "ZipInfo", "(", "filename", "+", "'.xml'", ")", "zi", ".", "external_attr", "=", "0660", "<<", "16L", "zf", ".", "writestr", "(", "zi", ",", "text", ")", "zf", ".", "close", "(", ")" ]

[ "Create", "an", "XML", "file", "(", "or", "MXL", "if", "compressed", ")", "for", "a", "given", "composition", "." ]

[ "def", "destroy_cloudwatch_log_event", "(", "app", "=", "''", ",", "env", "=", "'dev'", ",", "region", "=", "''", ")", ":", "session", "=", "boto3", ".", "Session", "(", "profile_name", "=", "env", ",", "region_name", "=", "region", ")", "cloudwatch_client", "=", "session", ".", "client", "(", "'logs'", ")", "# FIXME: see below", "# TODO: Log group name is required, where do we get it if it is not in application-master-env.json?", "cloudwatch_client", ".", "delete_subscription_filter", "(", "logGroupName", "=", "'/aws/lambda/awslimitchecker'", ",", "filterName", "=", "app", ")", "return", "True" ]

[ "Destroy", "Cloudwatch", "log", "event", "." ]

[ "def", "compile_extensions", "(", "macros", ",", "compat", "=", "False", ")", ":", "import", "distutils", ".", "sysconfig", "import", "distutils", ".", "ccompiler", "import", "tempfile", "import", "shutil", "from", "textwrap", "import", "dedent", "# common vars", "libraries", "=", "[", "'rrd'", "]", "include_dirs", "=", "[", "package_dir", ",", "'/usr/local/include'", "]", "library_dirs", "=", "[", "'/usr/local/lib'", "]", "compiler_args", "=", "dict", "(", "libraries", "=", "libraries", ",", "include_dirs", "=", "include_dirs", ",", "library_dirs", "=", "library_dirs", ",", "define_macros", "=", "macros", ")", "exts", "=", "[", "Extension", "(", "'rrdtool'", ",", "sources", "=", "[", "'rrdtoolmodule.c'", "]", ",", "*", "*", "compiler_args", ")", "]", "if", "compat", ":", "return", "exts", "# in non-compat mode, try to link to check if the new symbols are present in librrd", "c_code", "=", "dedent", "(", "'''\n #include <rrd.h>\n #include \"rrdtoolmodule.h\"\n\n int main(int argc, char *argv[]) {\n rrd_fetch_cb_register(NULL); /* exists in rrdtool >= 1.5.0 */\n return 0;\n }\n '''", ")", "tmp_dir", "=", "tempfile", ".", "mkdtemp", "(", "prefix", "=", "'tmp_python_rrdtool'", ")", "bin_file_name", "=", "os", ".", "path", ".", "join", "(", "tmp_dir", ",", "'test_rrdtool'", ")", "file_name", "=", "bin_file_name", "+", "'.c'", "with", "open", "(", "file_name", ",", "'w'", ")", "as", "fp", ":", "fp", ".", "write", "(", "c_code", ")", "# try to compile it", "compiler", "=", "distutils", ".", "ccompiler", ".", "new_compiler", "(", ")", "assert", "isinstance", "(", "compiler", ",", "distutils", ".", "ccompiler", ".", "CCompiler", ")", "for", "s", "in", "include_dirs", ":", "compiler", ".", "add_include_dir", "(", "s", ")", "for", "s", "in", "library_dirs", ":", "compiler", ".", "add_library_dir", "(", "s", ")", "for", "s", "in", "libraries", ":", "compiler", ".", "add_library", "(", "s", ")", "for", "s", "in", "macros", ":", "compiler", ".", "define_macro", "(", "*", "s", ")", "distutils", ".", "sysconfig", ".", "customize_compiler", "(", "compiler", ")", "try", ":", "compiler", ".", "link_executable", "(", "compiler", ".", "compile", "(", "[", "file_name", "]", ")", ",", "bin_file_name", ",", "libraries", "=", "libraries", ")", "except", "CompileError", ":", "sys", ".", "exit", "(", "'Error: Unable to compile the binary module. Do you have the rrdtool header and libraries installed?'", ")", "ret", "=", "None", "except", "LinkError", "as", "exc", ":", "shutil", ".", "rmtree", "(", "tmp_dir", ")", "raise", "# re-raise", "else", ":", "return", "exts", "# seems to be available, compile in regular way", "shutil", ".", "rmtree", "(", "tmp_dir", ")", "return", "ret" ]

[ "Compiler", "subroutine", "to", "test", "whether", "some", "functions", "are", "available", "on", "the", "target", "system", ".", "Since", "the", "rrdtool", "headers", "shipped", "with", "most", "packages", "do", "not", "disclose", "any", "versioning", "information", "we", "cannot", "test", "whether", "a", "given", "function", "is", "available", "that", "way", ".", "Instead", "use", "this", "to", "manually", "try", "to", "compile", "code", "and", "see", "if", "it", "works", "." ]

[ "def", "has_arg", "(", "fn", ",", "arg_name", ")", ":", "if", "sys", ".", "version_info", "<", "(", "3", ",", ")", ":", "if", "isinstance", "(", "fn", ",", "types", ".", "FunctionType", ")", "or", "isinstance", "(", "fn", ",", "types", ".", "MethodType", ")", ":", "arg_spec", "=", "inspect", ".", "getargspec", "(", "fn", ")", "else", ":", "try", ":", "arg_spec", "=", "inspect", ".", "getargspec", "(", "fn", ".", "__call__", ")", "except", "AttributeError", ":", "return", "False", "return", "(", "arg_name", "in", "arg_spec", ".", "args", ")", "elif", "sys", ".", "version_info", "<", "(", "3", ",", "6", ")", ":", "arg_spec", "=", "inspect", ".", "getfullargspec", "(", "fn", ")", "return", "(", "arg_name", "in", "arg_spec", ".", "args", "or", "arg_name", "in", "arg_spec", ".", "kwonlyargs", ")", "else", ":", "try", ":", "signature", "=", "inspect", ".", "signature", "(", "fn", ")", "except", "ValueError", ":", "# handling Cython", "signature", "=", "inspect", ".", "signature", "(", "fn", ".", "__call__", ")", "parameter", "=", "signature", ".", "parameters", ".", "get", "(", "arg_name", ")", "if", "parameter", "is", "None", ":", "return", "False", "return", "(", "parameter", ".", "kind", "in", "(", "inspect", ".", "Parameter", ".", "POSITIONAL_OR_KEYWORD", ",", "inspect", ".", "Parameter", ".", "KEYWORD_ONLY", ")", ")" ]

[ "Checks", "if", "a", "callable", "accepts", "a", "given", "keyword", "argument", "." ]

[ "def", "hide_routemap_holder_route_map_content_match_extcommunity_extcommunity_num", "(", "self", ",", "*", "*", "kwargs", ")", ":", "config", "=", "ET", ".", "Element", "(", "\"config\"", ")", "hide_routemap_holder", "=", "ET", ".", "SubElement", "(", "config", ",", "\"hide-routemap-holder\"", ",", "xmlns", "=", "\"urn:brocade.com:mgmt:brocade-ip-policy\"", ")", "route_map", "=", "ET", ".", "SubElement", "(", "hide_routemap_holder", ",", "\"route-map\"", ")", "name_key", "=", "ET", ".", "SubElement", "(", "route_map", ",", "\"name\"", ")", "name_key", ".", "text", "=", "kwargs", ".", "pop", "(", "'name'", ")", "action_rm_key", "=", "ET", ".", "SubElement", "(", "route_map", ",", "\"action-rm\"", ")", "action_rm_key", ".", "text", "=", "kwargs", ".", "pop", "(", "'action_rm'", ")", "instance_key", "=", "ET", ".", "SubElement", "(", "route_map", ",", "\"instance\"", ")", "instance_key", ".", "text", "=", "kwargs", ".", "pop", "(", "'instance'", ")", "content", "=", "ET", ".", "SubElement", "(", "route_map", ",", "\"content\"", ")", "match", "=", "ET", ".", "SubElement", "(", "content", ",", "\"match\"", ")", "extcommunity", "=", "ET", ".", "SubElement", "(", "match", ",", "\"extcommunity\"", ")", "extcommunity_num", "=", "ET", ".", "SubElement", "(", "extcommunity", ",", "\"extcommunity-num\"", ")", "extcommunity_num", ".", "text", "=", "kwargs", ".", "pop", "(", "'extcommunity_num'", ")", "callback", "=", "kwargs", ".", "pop", "(", "'callback'", ",", "self", ".", "_callback", ")", "return", "callback", "(", "config", ")" ]

[ "Auto", "Generated", "Code" ]

[ "def", "_dispatcher", "(", "self", ",", "connection", ",", "event", ")", ":", "super", "(", "BaseBot", ",", "self", ")", ".", "_dispatcher", "(", "connection", ",", "event", ")", "for", "handler", "in", "self", ".", "events", "[", "event", ".", "eventtype", "(", ")", "]", ":", "handler", "(", "self", ",", "connection", ",", "event", ")" ]

[ "This", "is", "the", "method", "in", "SimpleIRCClient", "that", "all", "IRC", "events", "get", "passed", "through", ".", "Here", "we", "map", "events", "to", "our", "own", "custom", "event", "handlers", "and", "call", "them", "." ]

[ "def", "all_solidity_variables_used_as_args", "(", "self", ")", ":", "if", "self", ".", "_all_solidity_variables_used_as_args", "is", "None", ":", "self", ".", "_all_solidity_variables_used_as_args", "=", "self", ".", "_explore_functions", "(", "lambda", "x", ":", "self", ".", "_explore_func_nodes", "(", "x", ",", "self", ".", "_solidity_variable_in_internal_calls", ")", ")", "return", "self", ".", "_all_solidity_variables_used_as_args" ]

[ "Return", "the", "Soldiity", "variables", "directly", "used", "in", "a", "call" ]

[ "def", "wait_for_master_to_start", "(", "single_master", ")", ":", "i", "=", "0", "while", "True", ":", "try", ":", "r", "=", "requests", ".", "get", "(", "\"http://%s:4646/v1/status/leader\"", "%", "single_master", ")", "if", "r", ".", "status_code", "==", "200", ":", "break", "except", ":", "Log", ".", "debug", "(", "sys", ".", "exc_info", "(", ")", "[", "0", "]", ")", "Log", ".", "info", "(", "\"Waiting for cluster to come up... %s\"", "%", "i", ")", "time", ".", "sleep", "(", "1", ")", "if", "i", ">", "10", ":", "Log", ".", "error", "(", "\"Failed to start Nomad Cluster!\"", ")", "sys", ".", "exit", "(", "-", "1", ")", "i", "=", "i", "+", "1" ]

[ "Wait", "for", "a", "nomad", "master", "to", "start" ]

[ "def", "_mean_prediction", "(", "self", ",", "theta", ",", "theta_t", ",", "Y", ",", "scores", ",", "h", ",", "t_params", ")", ":", "Y_exp", "=", "Y", ".", "copy", "(", ")", "theta_exp", "=", "theta", ".", "copy", "(", ")", "theta_t_exp", "=", "theta_t", ".", "copy", "(", ")", "scores_exp", "=", "scores", ".", "copy", "(", ")", "#(TODO: vectorize the inner construction here) ", "for", "t", "in", "range", "(", "0", ",", "h", ")", ":", "new_value1", "=", "theta_t_exp", "[", "-", "1", "]", "+", "theta_exp", "[", "-", "1", "]", "+", "t_params", "[", "0", "]", "*", "scores_exp", "[", "-", "1", "]", "new_value2", "=", "theta_t_exp", "[", "-", "1", "]", "+", "t_params", "[", "1", "]", "*", "scores_exp", "[", "-", "1", "]", "if", "self", ".", "model_name2", "==", "\"Exponential\"", ":", "Y_exp", "=", "np", ".", "append", "(", "Y_exp", ",", "[", "1.0", "/", "self", ".", "link", "(", "new_value1", ")", "]", ")", "else", ":", "Y_exp", "=", "np", ".", "append", "(", "Y_exp", ",", "[", "self", ".", "link", "(", "new_value1", ")", "]", ")", "theta_exp", "=", "np", ".", "append", "(", "theta_exp", ",", "[", "new_value1", "]", ")", "# For indexing consistency", "theta_t_exp", "=", "np", ".", "append", "(", "theta_t_exp", ",", "[", "new_value2", "]", ")", "scores_exp", "=", "np", ".", "append", "(", "scores_exp", ",", "[", "0", "]", ")", "# expectation of score is zero", "return", "Y_exp" ]

[ "Creates", "a", "h", "-", "step", "ahead", "mean", "prediction" ]

[ "def", "__calculate_changes", "(", "self", ",", "updated_centers", ")", ":", "changes", "=", "numpy", ".", "sum", "(", "numpy", ".", "square", "(", "self", ".", "__centers", "-", "updated_centers", ")", ",", "axis", "=", "1", ")", ".", "T", "return", "numpy", ".", "max", "(", "changes", ")" ]

[ "!" ]

[ "def", "send_string", "(", "self", ",", "string", ":", "str", ")", ":", "if", "not", "string", ":", "return", "string", "=", "string", ".", "replace", "(", "'\\n'", ",", "\"<enter>\"", ")", "string", "=", "string", ".", "replace", "(", "'\\t'", ",", "\"<tab>\"", ")", "_logger", ".", "debug", "(", "\"Send via event interface\"", ")", "self", ".", "__clearModifiers", "(", ")", "modifiers", "=", "[", "]", "for", "section", "in", "KEY_SPLIT_RE", ".", "split", "(", "string", ")", ":", "if", "len", "(", "section", ")", ">", "0", ":", "if", "Key", ".", "is_key", "(", "section", "[", ":", "-", "1", "]", ")", "and", "section", "[", "-", "1", "]", "==", "'+'", "and", "section", "[", ":", "-", "1", "]", "in", "MODIFIERS", ":", "# Section is a modifier application (modifier followed by '+')", "modifiers", ".", "append", "(", "section", "[", ":", "-", "1", "]", ")", "else", ":", "if", "len", "(", "modifiers", ")", ">", "0", ":", "# Modifiers ready for application - send modified key", "if", "Key", ".", "is_key", "(", "section", ")", ":", "self", ".", "interface", ".", "send_modified_key", "(", "section", ",", "modifiers", ")", "modifiers", "=", "[", "]", "else", ":", "self", ".", "interface", ".", "send_modified_key", "(", "section", "[", "0", "]", ",", "modifiers", ")", "if", "len", "(", "section", ")", ">", "1", ":", "self", ".", "interface", ".", "send_string", "(", "section", "[", "1", ":", "]", ")", "modifiers", "=", "[", "]", "else", ":", "# Normal string/key operation", "if", "Key", ".", "is_key", "(", "section", ")", ":", "self", ".", "interface", ".", "send_key", "(", "section", ")", "else", ":", "self", ".", "interface", ".", "send_string", "(", "section", ")", "self", ".", "__reapplyModifiers", "(", ")" ]

[ "Sends", "the", "given", "string", "for", "output", "." ]

[ "def", "format_time_trigger_string", "(", "timer_instance", ")", ":", "if", "isinstance", "(", "timer_instance", ",", "RepeatTimer", ")", ":", "return", "TRIGGER_PREAMBLE_EVERY", "+", "str", "(", "timer_instance", ".", "interval_new", ")", "elif", "isinstance", "(", "timer_instance", ",", "EventClock", ")", ":", "timestamps", "=", "[", "repr", "(", "x", ")", "for", "x", "in", "timer_instance", ".", "timestamps", "]", "return", "TRIGGER_PREAMBLE_AT", "+", "','", ".", "join", "(", "timestamps", ")", "else", ":", "raise", "ValueError", "(", "'Unknown timer instance type {0}'", ".", "format", "(", "timer_instance", ".", "__class__", ".", "__name__", ")", ")" ]

[ ":", "param", "timer_instance", ":", "either", "instance", "of", "RepeatTimer", "or", "EventClock", ":", "return", ":", "human", "-", "readable", "and", "editable", "string", "in", "one", "of", "two", "formats", ":", "-", "at", "Day_of_Week", "-", "HH", ":", "MM", "...", "Day_of_Week", "-", "HH", ":", "MM", "-", "every", "NNN" ]

[ "def", "facilityMsToNet", "(", "SsVersionIndicator_presence", "=", "0", ")", ":", "a", "=", "TpPd", "(", "pd", "=", "0x3", ")", "b", "=", "MessageType", "(", "mesType", "=", "0x3a", ")", "# 00111010", "c", "=", "Facility", "(", ")", "packet", "=", "a", "/", "b", "/", "c", "if", "SsVersionIndicator_presence", "is", "1", ":", "d", "=", "SsVersionIndicatorHdr", "(", "ieiSVI", "=", "0x7F", ",", "eightBitSVI", "=", "0x0", ")", "packet", "=", "packet", "/", "d", "return", "packet" ]

[ "FACILITY", "Section", "9", ".", "3", ".", "9", ".", "2" ]

[ "def", "set_limits_for_pool", "(", "self", ",", "pool", ",", "*", "*", "kw", ")", ":", "pool_limits", "=", "{", "}", "for", "time_period", "in", "[", "\"year\"", ",", "\"month\"", ",", "\"week\"", ",", "\"day\"", ",", "\"hour\"", "]", ":", "if", "time_period", "not", "in", "kw", ":", "continue", "limit", "=", "kw", ".", "pop", "(", "time_period", ")", "if", "limit", "is", "not", "None", "and", "not", "isinstance", "(", "limit", ",", "(", "float", ",", "int", ")", ")", ":", "raise", "TypeError", "(", "\"%s must be a float or int or None\"", ",", "time_period", ")", "pool_limits", "[", "time_period", "]", "=", "limit", "if", "kw", ":", "raise", "ValueError", "(", "\"Unknown time periods specified: %s\"", "%", "\", \"", ".", "join", "(", "kw", ".", "keys", "(", ")", ")", ")", "self", ".", "cache", ".", "set", "(", "\"LIMIT:%s\"", "%", "pool", ",", "json_dumps", "(", "pool_limits", ")", ")", "return" ]

[ "meterer", ".", "set_limits_for_pool", "(", "pool", "[", "time_period", "=", "value", "]", ")" ]

[ "def", "check_simulation", "(", "wdir", ")", ":", "wdir", "=", "pathlib", ".", "Path", "(", "wdir", ")", "field", "=", "wdir", "/", "\"V_0Ereim.dat\"", "if", "not", "(", "field", ".", "exists", "(", ")", "and", "field", ".", "stat", "(", ")", ".", "st_size", ">", "130", ")", ":", "msg", "=", "\"Output {} does not exist or is too small!\"", ".", "format", "(", "field", ")", "raise", "BHFIELDExecutionError", "(", "msg", ")" ]

[ "Check", "bhdebug", ".", "txt", "to", "make", "sure", "that", "you", "specify", "enough", "digits", "to", "overcome", "roundoff", "errors", "." ]

[ "def", "load_module", "(", "ldr", ",", "fqname", ")", ":", "scope", "=", "ldr", ".", "scope", ".", "split", "(", "'.'", ")", "modpath", "=", "fqname", ".", "split", "(", "'.'", ")", "if", "scope", "!=", "modpath", "[", "0", ":", "len", "(", "scope", ")", "]", ":", "raise", "AssertionError", "(", "\"%s responsible for %s got request for %s\"", "%", "(", "ldr", ".", "__class__", ".", "__name__", ",", "ldr", ".", "scope", ",", "fqname", ",", ")", ")", "if", "fqname", "in", "sys", ".", "modules", ":", "mod", "=", "sys", ".", "modules", "[", "fqname", "]", "else", ":", "mod", "=", "sys", ".", "modules", ".", "setdefault", "(", "fqname", ",", "types", ".", "ModuleType", "(", "fqname", ")", ")", "mod", ".", "__loader__", "=", "ldr", "fspath", "=", "ldr", ".", "path_to", "(", "fqname", ")", "mod", ".", "__file__", "=", "str", "(", "fspath", ")", "if", "fs", ".", "is_package", "(", "fspath", ")", ":", "mod", ".", "__path__", "=", "[", "ldr", ".", "fspath", "]", "mod", ".", "__package__", "=", "str", "(", "fqname", ")", "else", ":", "mod", ".", "__package__", "=", "str", "(", "fqname", ".", "rpartition", "(", "'.'", ")", "[", "0", "]", ")", "exec", "(", "fs", ".", "get_code", "(", "fspath", ")", ",", "mod", ".", "__dict__", ")", "return", "mod" ]

[ "Load", "fqname", "from", "under", "ldr", ".", "fspath", "." ]

[ "def", "show", "(", "self", ")", ":", "IPython", ".", "display", ".", "display", "(", "IPython", ".", "display", ".", "HTML", "(", "self", ".", "as_html", "(", ")", ")", ")" ]

[ "Publish", "HTML", "." ]

[ "def", "_count_righthand_zero_bits", "(", "number", ",", "bits", ")", ":", "if", "number", "==", "0", ":", "return", "bits", "for", "i", "in", "range", "(", "bits", ")", ":", "if", "(", "number", ">>", "i", ")", "&", "1", ":", "return", "i", "# All bits of interest were zero, even if there are more in the number", "return", "bits" ]

[ "Count", "the", "number", "of", "zero", "bits", "on", "the", "right", "hand", "side", "." ]

[ "def", "actors", "(", "context", ")", ":", "fritz", "=", "context", ".", "obj", "fritz", ".", "login", "(", ")", "for", "actor", "in", "fritz", ".", "get_actors", "(", ")", ":", "click", ".", "echo", "(", "\"{} ({} {}; AIN {} )\"", ".", "format", "(", "actor", ".", "name", ",", "actor", ".", "manufacturer", ",", "actor", ".", "productname", ",", "actor", ".", "actor_id", ",", ")", ")", "if", "actor", ".", "has_temperature", ":", "click", ".", "echo", "(", "\"Temp: act {} target {}; battery (low): {}\"", ".", "format", "(", "actor", ".", "temperature", ",", "actor", ".", "target_temperature", ",", "actor", ".", "battery_low", ",", ")", ")", "click", ".", "echo", "(", "\"Temp (via get): act {} target {}\"", ".", "format", "(", "actor", ".", "get_temperature", "(", ")", ",", "actor", ".", "get_target_temperature", "(", ")", ",", ")", ")" ]

[ "Display", "a", "list", "of", "actors" ]

[ "def", "onReactionAdded", "(", "self", ",", "mid", "=", "None", ",", "reaction", "=", "None", ",", "author_id", "=", "None", ",", "thread_id", "=", "None", ",", "thread_type", "=", "None", ",", "ts", "=", "None", ",", "msg", "=", "None", ",", ")", ":", "log", ".", "info", "(", "\"{} reacted to message {} with {} in {} ({})\"", ".", "format", "(", "author_id", ",", "mid", ",", "reaction", ".", "name", ",", "thread_id", ",", "thread_type", ".", "name", ")", ")" ]

[ "Called", "when", "the", "client", "is", "listening", "and", "somebody", "reacts", "to", "a", "message" ]

[ "def", "require", "(", "packages", ")", ":", "global", "INSTALLED_PACKAGES", ",", "_new_requirements", "if", "_new_requirements", ":", "INSTALLED_PACKAGES", "=", "None", "set_installed_packages", "(", ")", "if", "not", "INSTALLED_PACKAGES", ":", "return", "if", "not", "isinstance", "(", "packages", ",", "list", ")", ":", "packages", "=", "[", "packages", "]", "missing", "=", "[", "]", "for", "package", "in", "packages", ":", "name", "=", "re", ".", "split", "(", "r'[!<>=]'", ",", "package", ")", "[", "0", "]", ".", "lower", "(", ")", "if", "name", "not", "in", "INSTALLED_PACKAGES", ":", "print", "(", "ansi", ".", "info", "(", ")", "+", "' %s is required.'", "%", "package", ")", "missing", "+=", "[", "package", "]", "if", "missing", ":", "mode", "=", "'a'", "if", "os", ".", "path", ".", "exists", "(", "REQUIREMENTS", ")", "else", "'w'", "with", "open", "(", "REQUIREMENTS", ",", "mode", ")", "as", "requirements", ":", "requirements", ".", "write", "(", "'\\n'", "+", "'\\n'", ".", "join", "(", "missing", ")", "+", "'\\n'", ")", "print", "(", "ansi", ".", "info", "(", ")", "+", "' Dependencies added to requirements.txt. Rebooting.'", ")", "_new_requirements", "=", "True", "import", "lore", ".", "__main__", "lore", ".", "__main__", ".", "install", "(", "None", ",", "None", ")", "reboot", "(", "'--env-checked'", ")" ]

[ "Ensures", "that", "a", "pypi", "package", "has", "been", "installed", "into", "the", "App", "s", "python", "environment", ".", "If", "not", "the", "package", "will", "be", "installed", "and", "your", "env", "will", "be", "rebooted", "." ]

[ "def", "htmlDocContentDumpOutput", "(", "self", ",", "buf", ",", "encoding", ")", ":", "if", "buf", "is", "None", ":", "buf__o", "=", "None", "else", ":", "buf__o", "=", "buf", ".", "_o", "libxml2mod", ".", "htmlDocContentDumpOutput", "(", "buf__o", ",", "self", ".", "_o", ",", "encoding", ")" ]

[ "Dump", "an", "HTML", "document", ".", "Formating", "return", "/", "spaces", "are", "added", "." ]

[ "def", "register_token_getter", "(", "self", ",", "provider", ")", ":", "app", "=", "oauth", ".", "remote_apps", "[", "provider", "]", "decorator", "=", "getattr", "(", "app", ",", "'tokengetter'", ")", "def", "getter", "(", "token", "=", "None", ")", ":", "return", "self", ".", "token_getter", "(", "provider", ",", "token", ")", "decorator", "(", "getter", ")" ]

[ "Register", "callback", "to", "retrieve", "token", "from", "session" ]

[ "def", "_pluralize", "(", "value", ",", "item_key", ")", ":", "v", "=", "value", "[", "item_key", "]", "if", "not", "isinstance", "(", "v", ",", "list", ")", ":", "# Force a singular value to be a list", "return", "[", "v", "]", "else", ":", "return", "v" ]

[ "Force", "the", "value", "of", "a", "datacite3", "key", "to", "be", "a", "list", "." ]

[ "def", "diff", "(", "ctx", ",", "branch", ")", ":", "diff", "=", "GitDiffReporter", "(", "branch", ")", "regions", "=", "diff", ".", "changed_intervals", "(", ")", "_report_from_regions", "(", "regions", ",", "ctx", ".", "obj", ",", "file_factory", "=", "diff", ".", "old_file", ")" ]

[ "Determine", "which", "tests", "intersect", "a", "git", "diff", "." ]

[ "def", "run", "(", "self", ")", ":", "server_address", "=", "(", "self", ".", "host", ",", "self", ".", "port", ")", "threading", "=", "True", "if", "threading", ":", "httpd_cls", "=", "type", "(", "'WSGIServer'", ",", "(", "ThreadingMixIn", ",", "WSGIServer", ")", ",", "{", "}", ")", "else", ":", "httpd_cls", "=", "WSGIServer", "self", ".", "httpd", "=", "httpd_cls", "(", "server_address", ",", "WSGIRequestHandler", ",", "ipv6", "=", "False", ")", "wsgi_handler", "=", "get_internal_wsgi_application", "(", ")", "self", ".", "httpd", ".", "set_app", "(", "wsgi_handler", ")", "self", ".", "is_ready", ".", "set", "(", ")", "self", ".", "httpd", ".", "serve_forever", "(", ")" ]

[ "Sets", "up", "the", "live", "server", "and", "databases", "and", "then", "loops", "over", "handling", "http", "requests", "." ]

[ "def", "string_to_daterange", "(", "str_range", ",", "delimiter", "=", "'-'", ",", "as_dates", "=", "False", ",", "interval", "=", "CLOSED_CLOSED", ")", ":", "num_dates", "=", "str_range", ".", "count", "(", "delimiter", ")", "+", "1", "if", "num_dates", ">", "2", ":", "raise", "ValueError", "(", "'Too many dates in input string [%s] with delimiter (%s)'", "%", "(", "str_range", ",", "delimiter", ")", ")", "# Allow the user to use the [date-date), etc. range syntax to specify the interval.", "range_mode", "=", "Ranges", ".", "get", "(", "str_range", "[", "0", "]", "+", "str_range", "[", "-", "1", "]", ",", "None", ")", "if", "range_mode", ":", "return", "string_to_daterange", "(", "str_range", "[", "1", ":", "-", "1", "]", ",", "delimiter", ",", "as_dates", ",", "interval", "=", "range_mode", ")", "if", "as_dates", ":", "parse_dt", "=", "lambda", "s", ":", "parse", "(", "s", ")", ".", "date", "(", ")", "if", "s", "else", "None", "else", ":", "parse_dt", "=", "lambda", "s", ":", "parse", "(", "s", ")", "if", "s", "else", "None", "if", "num_dates", "==", "2", ":", "d", "=", "[", "parse_dt", "(", "x", ")", "for", "x", "in", "str_range", ".", "split", "(", "delimiter", ")", "]", "oc", "=", "interval", "else", ":", "start", "=", "parse_dt", "(", "str_range", ")", "d", "=", "[", "start", ",", "start", "+", "datetime", ".", "timedelta", "(", "1", ")", "]", "oc", "=", "CLOSED_OPEN", "# Always use closed-open for a single date/datetime.", "return", "DateRange", "(", "d", "[", "0", "]", ",", "d", "[", "1", "]", ",", "oc", ")" ]

[ "Convert", "a", "string", "to", "a", "DateRange", "type", ".", "If", "you", "put", "only", "one", "date", "it", "generates", "the", "relevant", "range", "for", "just", "that", "date", "or", "datetime", "till", "24", "hours", "later", ".", "You", "can", "optionally", "use", "mixtures", "of", "[]", "/", "()", "around", "the", "DateRange", "for", "OPEN", "/", "CLOSED", "interval", "behaviour", "." ]

[ "def", "empty_topic", "(", "self", ",", "topic", ")", ":", "nsq", ".", "assert_valid_topic_name", "(", "topic", ")", "return", "self", ".", "_request", "(", "'POST'", ",", "'/topic/empty'", ",", "fields", "=", "{", "'topic'", ":", "topic", "}", ")" ]

[ "Empty", "all", "the", "queued", "messages", "for", "an", "existing", "topic", "." ]

[ "async", "def", "delete", "(", "self", ",", "iden", ")", ":", "appt", "=", "self", ".", "appts", ".", "get", "(", "iden", ")", "if", "appt", "is", "None", ":", "raise", "s_exc", ".", "NoSuchIden", "(", ")", "try", ":", "heappos", "=", "self", ".", "apptheap", ".", "index", "(", "appt", ")", "except", "ValueError", ":", "pass", "# this is OK, just a non-recurring appt that has no more records", "else", ":", "# If we're already the last item, just delete it", "if", "heappos", "==", "len", "(", "self", ".", "apptheap", ")", "-", "1", ":", "del", "self", ".", "apptheap", "[", "heappos", "]", "else", ":", "# put the last item at the current position and reheap", "self", ".", "apptheap", "[", "heappos", "]", "=", "self", ".", "apptheap", ".", "pop", "(", ")", "heapq", ".", "heapify", "(", "self", ".", "apptheap", ")", "del", "self", ".", "appts", "[", "iden", "]", "await", "self", ".", "_hivedict", ".", "pop", "(", "iden", ")" ]

[ "Delete", "an", "appointment" ]

[ "def", "_next_method", "(", "self", ")", ":", "queue", "=", "self", ".", "queue", "put", "=", "self", ".", "_quick_put", "read_frame", "=", "self", ".", "source", ".", "read_frame", "while", "not", "queue", ":", "try", ":", "frame_type", ",", "channel", ",", "payload", "=", "read_frame", "(", ")", "except", "Exception", "as", "exc", ":", "#", "# Connection was closed? Framing Error?", "#", "put", "(", "exc", ")", "break", "self", ".", "bytes_recv", "+=", "1", "if", "frame_type", "not", "in", "(", "self", ".", "expected_types", "[", "channel", "]", ",", "8", ")", ":", "put", "(", "(", "channel", ",", "UnexpectedFrame", "(", "'Received frame {0} while expecting type: {1}'", ".", "format", "(", "frame_type", ",", "self", ".", "expected_types", "[", "channel", "]", ")", ")", ")", ")", "elif", "frame_type", "==", "1", ":", "self", ".", "_process_method_frame", "(", "channel", ",", "payload", ")", "elif", "frame_type", "==", "2", ":", "self", ".", "_process_content_header", "(", "channel", ",", "payload", ")", "elif", "frame_type", "==", "3", ":", "self", ".", "_process_content_body", "(", "channel", ",", "payload", ")", "elif", "frame_type", "==", "8", ":", "self", ".", "_process_heartbeat", "(", "channel", ",", "payload", ")" ]

[ "Read", "the", "next", "method", "from", "the", "source", "once", "one", "complete", "method", "has", "been", "assembled", "it", "is", "placed", "in", "the", "internal", "queue", "." ]

[ "def", "deselect_nodenames", "(", "self", ",", "*", "substrings", ":", "str", ")", "->", "'Selection'", ":", "self", ".", "nodes", "-=", "self", ".", "search_nodenames", "(", "*", "substrings", ")", ".", "nodes", "return", "self" ]

[ "Restrict", "the", "current", "selection", "to", "all", "nodes", "with", "a", "name", "not", "containing", "at", "least", "one", "of", "the", "given", "substrings", "(", "does", "not", "affect", "any", "elements", ")", "." ]

[ "def", "request_object", "(", "self", ")", ":", "obj_to_return", "=", "None", "if", "self", ".", "queue", ".", "count", ">", "0", ":", "obj_to_return", "=", "self", ".", "__dequeue", "(", ")", "else", ":", "#The queue is empty, generate a new item.", "self", ".", "__init_object", "(", ")", "object_to_return", "=", "self", ".", "__dequeue", "(", ")", "self", ".", "active_objects", "+=", "1", "return", "obj_to_return" ]

[ "Grab", "an", "object", "from", "the", "pool", ".", "If", "the", "pool", "is", "empty", "a", "new", "object", "will", "be", "generated", "and", "returned", "." ]

[ "def", "_add_to_typedef", "(", "self", ",", "typedef_curr", ",", "line", ",", "lnum", ")", ":", "mtch", "=", "re", ".", "match", "(", "r'^(\\S+):\\s*(\\S.*)$'", ",", "line", ")", "if", "mtch", ":", "field_name", "=", "mtch", ".", "group", "(", "1", ")", "field_value", "=", "mtch", ".", "group", "(", "2", ")", ".", "split", "(", "'!'", ")", "[", "0", "]", ".", "rstrip", "(", ")", "if", "field_name", "==", "\"id\"", ":", "self", ".", "_chk_none", "(", "typedef_curr", ".", "id", ",", "lnum", ")", "typedef_curr", ".", "id", "=", "field_value", "elif", "field_name", "==", "\"name\"", ":", "self", ".", "_chk_none", "(", "typedef_curr", ".", "name", ",", "lnum", ")", "typedef_curr", ".", "name", "=", "field_value", "elif", "field_name", "==", "\"transitive_over\"", ":", "typedef_curr", ".", "transitive_over", ".", "append", "(", "field_value", ")", "elif", "field_name", "==", "\"inverse_of\"", ":", "self", ".", "_chk_none", "(", "typedef_curr", ".", "inverse_of", ",", "lnum", ")", "typedef_curr", ".", "inverse_of", "=", "field_value", "# Note: there are other tags that aren't imported here.", "else", ":", "self", ".", "_die", "(", "\"UNEXPECTED FIELD CONTENT: {L}\\n\"", ".", "format", "(", "L", "=", "line", ")", ",", "lnum", ")" ]

[ "Add", "new", "fields", "to", "the", "current", "typedef", "." ]

[ "def", "counter_format", "(", "counter", ")", ":", "if", "not", "counter", ":", "return", "\"na\"", "return", "\",\"", ".", "join", "(", "\"{}:{}\"", ".", "format", "(", "*", "z", ")", "for", "z", "in", "sorted", "(", "counter", ".", "items", "(", ")", ")", ")" ]

[ "Pretty", "print", "a", "counter", "so", "that", "it", "appears", "as", ":", "2", ":", "200", "3", ":", "100", "4", ":", "20" ]

[ "def", "on_post", "(", "self", ",", "req", ",", "resp", ",", "rid", ")", ":", "signals", ".", "pre_req", ".", "send", "(", "self", ".", "model", ")", "signals", ".", "pre_req_upload", ".", "send", "(", "self", ".", "model", ")", "props", "=", "req", ".", "deserialize", "(", "self", ".", "mimetypes", ")", "model", "=", "find", "(", "self", ".", "model", ",", "rid", ")", "signals", ".", "pre_upload", ".", "send", "(", "self", ".", "model", ",", "model", "=", "model", ")", "try", ":", "conn", "=", "s3_connect", "(", "self", ".", "key", ",", "self", ".", "secret", ")", "path", "=", "self", ".", "_gen_s3_path", "(", "model", ",", "props", ")", "s3_url", "=", "s3_upload", "(", "self", ".", "acl", ",", "self", ".", "bucket", ",", "conn", ",", "props", "[", "'content'", "]", ",", "props", "[", "'content-type'", "]", ",", "path", ")", "except", "IOError", ":", "abort", "(", "ServiceUnavailable", "(", "*", "*", "{", "'detail'", ":", "'The upload attempt failed unexpectedly'", ",", "}", ")", ")", "else", ":", "signals", ".", "post_upload", ".", "send", "(", "self", ".", "model", ",", "model", "=", "model", ",", "url", "=", "s3_url", ")", "resp", ".", "location", "=", "s3_url", "resp", ".", "status", "=", "falcon", ".", "HTTP_201", "resp", ".", "serialize", "(", "{", "'data'", ":", "{", "'url'", ":", "s3_url", "}", "}", ")", "signals", ".", "post_req", ".", "send", "(", "self", ".", "model", ")", "signals", ".", "post_req_upload", ".", "send", "(", "self", ".", "model", ")" ]

[ "Deserialize", "the", "file", "upload", "&", "save", "it", "to", "S3" ]

[ "def", "do_rating_by_request", "(", "parser", ",", "token", ")", ":", "bits", "=", "token", ".", "contents", ".", "split", "(", ")", "if", "len", "(", "bits", ")", "!=", "6", ":", "raise", "template", ".", "TemplateSyntaxError", "(", "\"'%s' tag takes exactly five arguments\"", "%", "bits", "[", "0", "]", ")", "if", "bits", "[", "2", "]", "!=", "'on'", ":", "raise", "template", ".", "TemplateSyntaxError", "(", "\"second argument to '%s' tag must be 'on'\"", "%", "bits", "[", "0", "]", ")", "if", "bits", "[", "4", "]", "!=", "'as'", ":", "raise", "template", ".", "TemplateSyntaxError", "(", "\"fourth argument to '%s' tag must be 'as'\"", "%", "bits", "[", "0", "]", ")", "return", "RatingByRequestNode", "(", "bits", "[", "1", "]", ",", "bits", "[", "3", "]", ",", "bits", "[", "5", "]", ")" ]

[ "Retrieves", "the", "Vote", "cast", "by", "a", "user", "on", "a", "particular", "object", "and", "stores", "it", "in", "a", "context", "variable", ".", "If", "the", "user", "has", "not", "voted", "the", "context", "variable", "will", "be", "0", ".", "Example", "usage", "::", "{", "%", "rating_by_request", "request", "on", "instance", "as", "vote", "%", "}" ]

[ "def", "edge2geoff", "(", "from_node", ",", "to_node", ",", "properties", ",", "edge_relationship_name", ",", "encoder", ")", ":", "edge_string", "=", "None", "if", "properties", ":", "args", "=", "[", "from_node", ",", "edge_relationship_name", ",", "encoder", ".", "encode", "(", "properties", ")", ",", "to_node", "]", "edge_string", "=", "'({0})-[:{1} {2}]->({3})'", ".", "format", "(", "*", "args", ")", "else", ":", "args", "=", "[", "from_node", ",", "edge_relationship_name", ",", "to_node", "]", "edge_string", "=", "'({0})-[:{1}]->({2})'", ".", "format", "(", "*", "args", ")", "return", "edge_string" ]

[ "converts", "a", "NetworkX", "edge", "into", "a", "Geoff", "string", "." ]

[ "def", "style_node", "(", "self", ",", "additional_style_attrib", "=", "None", ")", ":", "style_attrib", "=", "{", "\"style:name\"", ":", "self", ".", "name", ",", "\"style:family\"", ":", "self", ".", "FAMILY", "}", "if", "additional_style_attrib", ":", "style_attrib", ".", "update", "(", "additional_style_attrib", ")", "if", "self", ".", "PARENT_STYLE_DICT", ":", "style_attrib", ".", "update", "(", "self", ".", "PARENT_STYLE_DICT", ")", "node", "=", "el", "(", "\"style:style\"", ",", "attrib", "=", "style_attrib", ")", "props", "=", "sub_el", "(", "node", ",", "self", ".", "STYLE_PROP", ",", "attrib", "=", "self", ".", "styles", ")", "return", "node" ]

[ "generate", "a", "style", "node", "(", "for", "automatic", "-", "styles", ")" ]

[ "def", "compute", "(", "self", ",", "inputs", ",", "outputs", ")", ":", "# Handle reset first (should be sent with an empty signal)", "if", "\"resetIn\"", "in", "inputs", ":", "assert", "len", "(", "inputs", "[", "\"resetIn\"", "]", ")", "==", "1", "if", "inputs", "[", "\"resetIn\"", "]", "[", "0", "]", "!=", "0", ":", "# send empty output", "self", ".", "reset", "(", ")", "outputs", "[", "\"feedForwardOutput\"", "]", "[", ":", "]", "=", "0", "outputs", "[", "\"activeCells\"", "]", "[", ":", "]", "=", "0", "return", "feedforwardInput", "=", "numpy", ".", "asarray", "(", "inputs", "[", "\"feedforwardInput\"", "]", ".", "nonzero", "(", ")", "[", "0", "]", ",", "dtype", "=", "\"uint32\"", ")", "if", "\"feedforwardGrowthCandidates\"", "in", "inputs", ":", "feedforwardGrowthCandidates", "=", "numpy", ".", "asarray", "(", "inputs", "[", "\"feedforwardGrowthCandidates\"", "]", ".", "nonzero", "(", ")", "[", "0", "]", ",", "dtype", "=", "\"uint32\"", ")", "else", ":", "feedforwardGrowthCandidates", "=", "feedforwardInput", "if", "\"lateralInput\"", "in", "inputs", ":", "lateralInputs", "=", "tuple", "(", "numpy", ".", "asarray", "(", "singleInput", ".", "nonzero", "(", ")", "[", "0", "]", ",", "dtype", "=", "\"uint32\"", ")", "for", "singleInput", "in", "numpy", ".", "split", "(", "inputs", "[", "\"lateralInput\"", "]", ",", "self", ".", "numOtherCorticalColumns", ")", ")", "else", ":", "lateralInputs", "=", "(", ")", "if", "\"predictedInput\"", "in", "inputs", ":", "predictedInput", "=", "numpy", ".", "asarray", "(", "inputs", "[", "\"predictedInput\"", "]", ".", "nonzero", "(", ")", "[", "0", "]", ",", "dtype", "=", "\"uint32\"", ")", "else", ":", "predictedInput", "=", "None", "# Send the inputs into the Column Pooler.", "self", ".", "_pooler", ".", "compute", "(", "feedforwardInput", ",", "lateralInputs", ",", "feedforwardGrowthCandidates", ",", "learn", "=", "self", ".", "learningMode", ",", "predictedInput", "=", "predictedInput", ")", "# Extract the active / predicted cells and put them into binary arrays.", "outputs", "[", "\"activeCells\"", "]", "[", ":", "]", "=", "0", "outputs", "[", "\"activeCells\"", "]", "[", "self", ".", "_pooler", ".", "getActiveCells", "(", ")", "]", "=", "1", "# Send appropriate output to feedForwardOutput.", "if", "self", ".", "defaultOutputType", "==", "\"active\"", ":", "outputs", "[", "\"feedForwardOutput\"", "]", "[", ":", "]", "=", "outputs", "[", "\"activeCells\"", "]", "else", ":", "raise", "Exception", "(", "\"Unknown outputType: \"", "+", "self", ".", "defaultOutputType", ")" ]

[ "Run", "one", "iteration", "of", "compute", "." ]

[ "def", "send_msg_async", "(", "self", ",", "*", ",", "message_type", ",", "user_id", "=", "None", ",", "group_id", "=", "None", ",", "discuss_id", "=", "None", ",", "message", ",", "auto_escape", "=", "False", ")", ":", "return", "super", "(", ")", ".", "__getattr__", "(", "'send_msg_async'", ")", "(", "message_type", "=", "message_type", ",", "user_id", "=", "user_id", ",", "group_id", "=", "group_id", ",", "discuss_id", "=", "discuss_id", ",", "message", "=", "message", ",", "auto_escape", "=", "auto_escape", ")" ]

[ "发送消息", "(", "异步版本", ")" ]

[ "def", "get_variables", "(", "expression", ",", "variables", "=", "None", ")", ":", "if", "variables", "is", "None", ":", "variables", "=", "set", "(", ")", "if", "hasattr", "(", "expression", ",", "'variable_name'", ")", "and", "expression", ".", "variable_name", "is", "not", "None", ":", "variables", ".", "add", "(", "expression", ".", "variable_name", ")", "if", "isinstance", "(", "expression", ",", "Operation", ")", ":", "for", "operand", "in", "op_iter", "(", "expression", ")", ":", "get_variables", "(", "operand", ",", "variables", ")", "return", "variables" ]

[ "Returns", "the", "set", "of", "variable", "names", "in", "the", "given", "expression", "." ]

[ "def", "adjoint", "(", "self", ")", ":", "if", "self", ".", "variant", "==", "'point_eval'", ":", "variant", "=", "'dirac'", "elif", "self", ".", "variant", "==", "'integrate'", ":", "variant", "=", "'char_fun'", "else", ":", "raise", "RuntimeError", "(", "'bad variant {!r}'", ".", "format", "(", "self", ".", "variant", ")", ")", "return", "WeightedSumSamplingOperator", "(", "self", ".", "domain", ",", "self", ".", "sampling_points", ",", "variant", ")" ]

[ "Adjoint", "of", "the", "sampling", "operator", "a", "WeightedSumSamplingOperator", "." ]

[ "def", "_sim_prediction", "(", "self", ",", "lmda", ",", "Y", ",", "scores", ",", "h", ",", "t_params", ",", "simulations", ")", ":", "sim_vector", "=", "np", ".", "zeros", "(", "[", "simulations", ",", "h", "]", ")", "for", "n", "in", "range", "(", "0", ",", "simulations", ")", ":", "# Create arrays to iteratre over ", "lmda_exp", "=", "lmda", ".", "copy", "(", ")", "scores_exp", "=", "scores", ".", "copy", "(", ")", "Y_exp", "=", "Y", ".", "copy", "(", ")", "# Loop over h time periods ", "for", "t", "in", "range", "(", "0", ",", "h", ")", ":", "new_value", "=", "t_params", "[", "0", "]", "if", "self", ".", "p", "!=", "0", ":", "for", "j", "in", "range", "(", "1", ",", "self", ".", "p", "+", "1", ")", ":", "new_value", "+=", "t_params", "[", "j", "]", "*", "lmda_exp", "[", "-", "j", "]", "if", "self", ".", "q", "!=", "0", ":", "for", "k", "in", "range", "(", "1", ",", "self", ".", "q", "+", "1", ")", ":", "new_value", "+=", "t_params", "[", "k", "+", "self", ".", "p", "]", "*", "scores_exp", "[", "-", "k", "]", "if", "self", ".", "leverage", "is", "True", ":", "new_value", "+=", "t_params", "[", "1", "+", "self", ".", "p", "+", "self", ".", "q", "]", "*", "np", ".", "sign", "(", "-", "(", "Y_exp", "[", "-", "1", "]", "-", "t_params", "[", "-", "2", "]", "-", "t_params", "[", "-", "1", "]", "*", "np", ".", "exp", "(", "lmda_exp", "[", "-", "1", "]", "/", "2.0", ")", ")", ")", "*", "(", "scores_exp", "[", "-", "1", "]", "+", "1", ")", "lmda_exp", "=", "np", ".", "append", "(", "lmda_exp", ",", "[", "new_value", "]", ")", "# For indexing consistency", "scores_exp", "=", "np", ".", "append", "(", "scores_exp", ",", "scores", "[", "np", ".", "random", ".", "randint", "(", "scores", ".", "shape", "[", "0", "]", ")", "]", ")", "# expectation of score is zero", "Y_exp", "=", "np", ".", "append", "(", "Y_exp", ",", "Y", "[", "np", ".", "random", ".", "randint", "(", "Y", ".", "shape", "[", "0", "]", ")", "]", ")", "# bootstrap returns", "sim_vector", "[", "n", "]", "=", "lmda_exp", "[", "-", "h", ":", "]", "return", "np", ".", "transpose", "(", "sim_vector", ")" ]

[ "Simulates", "a", "h", "-", "step", "ahead", "mean", "prediction" ]

[ "def", "run_in_buildenv", "(", "self", ",", "buildenv_target_name", ":", "str", ",", "cmd", ":", "list", ",", "cmd_env", ":", "dict", "=", "None", ",", "work_dir", ":", "str", "=", "None", ",", "auto_uid", ":", "bool", "=", "True", ",", "runtime", ":", "str", "=", "None", ",", "*", "*", "kwargs", ")", ":", "buildenv_target", "=", "self", ".", "targets", "[", "buildenv_target_name", "]", "# TODO(itamar): Assert that buildenv_target is up to date", "redirection", "=", "any", "(", "stream_key", "in", "kwargs", "for", "stream_key", "in", "(", "'stdin'", ",", "'stdout'", ",", "'stderr'", ",", "'input'", ")", ")", "docker_run", "=", "[", "'docker'", ",", "'run'", "]", "# if not self.conf.non_interactive:", "# docker_run.append('-i')", "if", "not", "redirection", ":", "docker_run", ".", "append", "(", "'-t'", ")", "project_vol", "=", "(", "self", ".", "conf", ".", "docker_volume", "if", "self", ".", "conf", ".", "docker_volume", "else", "self", ".", "conf", ".", "project_root", ")", "container_work_dir", "=", "PurePath", "(", "'/project'", ")", "if", "work_dir", ":", "container_work_dir", "/=", "work_dir", "if", "runtime", ":", "docker_run", ".", "extend", "(", "[", "'--runtime'", ",", "runtime", ",", "]", ")", "docker_run", ".", "extend", "(", "[", "'--rm'", ",", "'-v'", ",", "project_vol", "+", "':/project'", ",", "# TODO: windows containers?", "'-w'", ",", "container_work_dir", ".", "as_posix", "(", ")", ",", "]", ")", "if", "cmd_env", ":", "for", "key", ",", "value", "in", "cmd_env", ".", "items", "(", ")", ":", "# TODO(itamar): escaping", "docker_run", ".", "extend", "(", "[", "'-e'", ",", "'{}={}'", ".", "format", "(", "key", ",", "value", ")", "]", ")", "if", "platform", ".", "system", "(", ")", "==", "'Linux'", "and", "auto_uid", ":", "# Fix permissions for bind-mounted project dir", "# The fix is not needed when using Docker For Mac / Windows,", "# because it is somehow taken care of by the sharing mechanics", "docker_run", ".", "extend", "(", "[", "'-u'", ",", "'{}:{}'", ".", "format", "(", "os", ".", "getuid", "(", ")", ",", "os", ".", "getgid", "(", ")", ")", ",", "'-v'", ",", "'/etc/shadow:/etc/shadow:ro'", ",", "'-v'", ",", "'/etc/group:/etc/group:ro'", ",", "'-v'", ",", "'/etc/passwd:/etc/passwd:ro'", ",", "'-v'", ",", "'/etc/sudoers:/etc/sudoers:ro'", ",", "]", ")", "docker_run", ".", "append", "(", "format_qualified_image_name", "(", "buildenv_target", ")", ")", "docker_run", ".", "extend", "(", "cmd", ")", "logger", ".", "info", "(", "'Running command in build env \"{}\" using command {}'", ",", "buildenv_target_name", ",", "docker_run", ")", "# TODO: Consider changing the PIPEs to temp files.", "if", "'stderr'", "not", "in", "kwargs", ":", "kwargs", "[", "'stderr'", "]", "=", "PIPE", "if", "'stdout'", "not", "in", "kwargs", ":", "kwargs", "[", "'stdout'", "]", "=", "PIPE", "result", "=", "run", "(", "docker_run", ",", "check", "=", "True", ",", "*", "*", "kwargs", ")", "# TODO(Dana): Understand what is the right enconding and remove the", "# try except", "if", "kwargs", "[", "'stdout'", "]", "is", "PIPE", ":", "try", ":", "sys", ".", "stdout", ".", "write", "(", "result", ".", "stdout", ".", "decode", "(", "'utf-8'", ")", ")", "except", "UnicodeEncodeError", "as", "e", ":", "sys", ".", "stderr", ".", "write", "(", "'tried writing the stdout of {},\\n but it '", "'has a problematic character:\\n {}\\n'", "'hex dump of stdout:\\n{}\\n'", ".", "format", "(", "docker_run", ",", "str", "(", "e", ")", ",", "codecs", ".", "encode", "(", "result", ".", "stdout", ",", "'hex'", ")", ".", "decode", "(", "'utf8'", ")", ")", ")", "if", "kwargs", "[", "'stderr'", "]", "is", "PIPE", ":", "try", ":", "sys", ".", "stderr", ".", "write", "(", "result", ".", "stderr", ".", "decode", "(", "'utf-8'", ")", ")", "except", "UnicodeEncodeError", "as", "e", ":", "sys", ".", "stderr", ".", "write", "(", "'tried writing the stderr of {},\\n but it '", "'has a problematic character:\\n {}\\n'", "'hex dump of stderr:\\n{}\\n'", ".", "format", "(", "docker_run", ",", "str", "(", "e", ")", ",", "codecs", ".", "encode", "(", "result", ".", "stderr", ",", "'hex'", ")", ".", "decode", "(", "'utf8'", ")", ")", ")", "return", "result" ]

[ "Run", "a", "command", "in", "a", "named", "BuildEnv", "Docker", "image", "." ]

[ "def", "_marshal_settings", "(", "self", ")", ":", "result", "=", "{", "}", "for", "key", "in", "dir", "(", "settings", ")", ":", "if", "any", "(", "map", "(", "key", ".", "startswith", ",", "[", "'FLOW_'", ",", "'RESOLWE_'", ",", "'CELERY_'", "]", ")", ")", ":", "result", "[", "key", "]", "=", "getattr", "(", "settings", ",", "key", ")", "return", "result" ]

[ "Marshal", "Django", "settings", "into", "a", "serializable", "object", "." ]

[ "def", "request", "(", "self", ",", "send_terminator", "=", "False", ")", ":", "try", ":", "retA", "=", "self", ".", "requestA", "(", ")", "retB", "=", "self", ".", "requestB", "(", ")", "if", "retA", "and", "retB", ":", "self", ".", "makeAB", "(", ")", "self", ".", "calculateFields", "(", ")", "self", ".", "updateObservers", "(", ")", "return", "True", "except", ":", "ekm_log", "(", "traceback", ".", "format_exc", "(", "sys", ".", "exc_info", "(", ")", ")", ")", "return", "False" ]

[ "Combined", "A", "and", "B", "read", "for", "V4", "meter", "." ]

[ "def", "manages", "(", "self", ",", "cfg_part", ")", ":", "logger", ".", "debug", "(", "\"Do I (%s/%s) manage: %s, my managed configuration(s): %s\"", ",", "self", ".", "type", ",", "self", ".", "name", ",", "cfg_part", ",", "self", ".", "cfg_managed", ")", "# If we do not yet manage a configuration", "if", "not", "self", ".", "cfg_managed", ":", "logger", ".", "info", "(", "\"I (%s/%s) do not manage (yet) any configuration!\"", ",", "self", ".", "type", ",", "self", ".", "name", ")", "return", "False", "# Check in the schedulers list configurations", "for", "managed_cfg", "in", "list", "(", "self", ".", "cfg_managed", ".", "values", "(", ")", ")", ":", "# If not even the cfg_id in the managed_conf, bail out", "if", "managed_cfg", "[", "'managed_conf_id'", "]", "==", "cfg_part", ".", "instance_id", "and", "managed_cfg", "[", "'push_flavor'", "]", "==", "cfg_part", ".", "push_flavor", ":", "logger", ".", "debug", "(", "\"I do manage this configuration: %s\"", ",", "cfg_part", ")", "break", "else", ":", "logger", ".", "warning", "(", "\"I (%s/%s) do not manage this configuration: %s\"", ",", "self", ".", "type", ",", "self", ".", "name", ",", "cfg_part", ")", "return", "False", "return", "True" ]

[ "Tell", "if", "the", "satellite", "is", "managing", "this", "configuration", "part" ]

[ "def", "_get_base", "(", "*", "*", "kwargs", ")", ":", "profile", "=", "get_container_profile", "(", "copy", ".", "deepcopy", "(", "kwargs", ".", "get", "(", "'profile'", ")", ")", ")", "kw_overrides", "=", "copy", ".", "deepcopy", "(", "kwargs", ")", "def", "select", "(", "key", ",", "default", "=", "None", ")", ":", "kw_overrides_match", "=", "kw_overrides", ".", "pop", "(", "key", ",", "_marker", ")", "profile_match", "=", "profile", ".", "pop", "(", "key", ",", "default", ")", "# let kwarg overrides be the preferred choice", "if", "kw_overrides_match", "is", "_marker", ":", "return", "profile_match", "return", "kw_overrides_match", "template", "=", "select", "(", "'template'", ")", "image", "=", "select", "(", "'image'", ")", "vgname", "=", "select", "(", "'vgname'", ")", "path", "=", "kwargs", ".", "get", "(", "'path'", ",", "None", ")", "# remove the above three variables from kwargs, if they exist, to avoid", "# duplicates if create() is invoked below.", "for", "param", "in", "(", "'path'", ",", "'image'", ",", "'vgname'", ",", "'template'", ")", ":", "kwargs", ".", "pop", "(", "param", ",", "None", ")", "if", "image", ":", "proto", "=", "_urlparse", "(", "image", ")", ".", "scheme", "img_tar", "=", "__salt__", "[", "'cp.cache_file'", "]", "(", "image", ")", "img_name", "=", "os", ".", "path", ".", "basename", "(", "img_tar", ")", "hash_", "=", "salt", ".", "utils", ".", "hashutils", ".", "get_hash", "(", "img_tar", ",", "__salt__", "[", "'config.get'", "]", "(", "'hash_type'", ")", ")", "name", "=", "'__base_{0}_{1}_{2}'", ".", "format", "(", "proto", ",", "img_name", ",", "hash_", ")", "if", "not", "exists", "(", "name", ",", "path", "=", "path", ")", ":", "create", "(", "name", ",", "template", "=", "template", ",", "image", "=", "image", ",", "path", "=", "path", ",", "vgname", "=", "vgname", ",", "*", "*", "kwargs", ")", "if", "vgname", ":", "rootfs", "=", "os", ".", "path", ".", "join", "(", "'/dev'", ",", "vgname", ",", "name", ")", "edit_conf", "(", "info", "(", "name", ",", "path", "=", "path", ")", "[", "'config'", "]", ",", "out_format", "=", "'commented'", ",", "*", "*", "{", "'lxc.rootfs'", ":", "rootfs", "}", ")", "return", "name", "elif", "template", ":", "name", "=", "'__base_{0}'", ".", "format", "(", "template", ")", "if", "not", "exists", "(", "name", ",", "path", "=", "path", ")", ":", "create", "(", "name", ",", "template", "=", "template", ",", "image", "=", "image", ",", "path", "=", "path", ",", "vgname", "=", "vgname", ",", "*", "*", "kwargs", ")", "if", "vgname", ":", "rootfs", "=", "os", ".", "path", ".", "join", "(", "'/dev'", ",", "vgname", ",", "name", ")", "edit_conf", "(", "info", "(", "name", ",", "path", "=", "path", ")", "[", "'config'", "]", ",", "out_format", "=", "'commented'", ",", "*", "*", "{", "'lxc.rootfs'", ":", "rootfs", "}", ")", "return", "name", "return", "''" ]

[ "If", "the", "needed", "base", "does", "not", "exist", "then", "create", "it", "if", "it", "does", "exist", "create", "nothing", "and", "return", "the", "name", "of", "the", "base", "lxc", "container", "so", "it", "can", "be", "cloned", "." ]

[ "def", "download", "(", "self", ",", "directory", ",", "structure", "=", "True", ")", ":", "return", "self", ".", "manager", ".", "download", "(", "self", ",", "directory", ",", "structure", "=", "structure", ")" ]

[ "Fetches", "the", "object", "from", "storage", "and", "writes", "it", "to", "the", "specified", "directory", ".", "The", "directory", "must", "exist", "before", "calling", "this", "method", "." ]

[ "def", "read_PIA0_B_data", "(", "self", ",", "cpu_cycles", ",", "op_address", ",", "address", ")", ":", "value", "=", "self", ".", "pia_0_B_data", ".", "value", "# $ff02", "log", ".", "debug", "(", "\"%04x| read $%04x (PIA 0 B side Data reg.) send $%02x (%s) back.\\t|%s\"", ",", "op_address", ",", "address", ",", "value", ",", "byte2bit_string", "(", "value", ")", ",", "self", ".", "cfg", ".", "mem_info", ".", "get_shortest", "(", "op_address", ")", ")", "return", "value" ]

[ "read", "from", "0xff02", "-", ">", "PIA", "0", "B", "side", "Data", "reg", "." ]

[ "def", "delete_by_user_name", "(", "user_name", ")", ":", "try", ":", "del_count", "=", "TabMember", ".", "delete", "(", ")", ".", "where", "(", "TabMember", ".", "user_name", "==", "user_name", ")", "del_count", ".", "execute", "(", ")", "return", "True", "except", ":", "return", "False" ]

[ "Delete", "user", "in", "the", "database", "by", "user_name", "." ]

[ "def", "find_causal_link", "(", "self", ",", "direction", ",", "mechanism", ",", "purviews", "=", "False", ",", "allow_neg", "=", "False", ")", ":", "purviews", "=", "self", ".", "potential_purviews", "(", "direction", ",", "mechanism", ",", "purviews", ")", "# Find the maximal RIA over the remaining purviews.", "if", "not", "purviews", ":", "max_ria", "=", "_null_ac_ria", "(", "self", ".", "mechanism_state", "(", "direction", ")", ",", "direction", ",", "mechanism", ",", "None", ")", "else", ":", "# This max should be most positive", "max_ria", "=", "max", "(", "self", ".", "find_mip", "(", "direction", ",", "mechanism", ",", "purview", ",", "allow_neg", ")", "for", "purview", "in", "purviews", ")", "# Construct the corresponding CausalLink", "return", "CausalLink", "(", "max_ria", ")" ]

[ "Return", "the", "maximally", "irreducible", "cause", "or", "effect", "ratio", "for", "a", "mechanism", "." ]

[ "def", "__datetime_to_epoch", "(", "self", ",", "date_time", ")", ":", "date_time_utc", "=", "None", "if", "date_time", ".", "tzinfo", "is", "None", ":", "date_time_utc", "=", "date_time", ".", "replace", "(", "tzinfo", "=", "pytz", ".", "utc", ")", "else", ":", "date_time_utc", "=", "date_time", ".", "astimezone", "(", "pytz", ".", "utc", ")", "epoch_utc", "=", "datetime", ".", "datetime", ".", "utcfromtimestamp", "(", "0", ")", ".", "replace", "(", "tzinfo", "=", "pytz", ".", "utc", ")", "return", "(", "date_time_utc", "-", "epoch_utc", ")", ".", "total_seconds", "(", ")" ]

[ "Converts", "a", "python", "datetime", "to", "unix", "epoch", "accounting", "for", "time", "zones", "and", "such", "." ]

[ "def", "writeToken", "(", "self", ")", ":", "# Write token file privately.", "with", "os", ".", "fdopen", "(", "os", ".", "open", "(", "self", ".", "tokenFile", ",", "os", ".", "O_WRONLY", "|", "os", ".", "O_CREAT", ",", "0o600", ")", ",", "\"w\"", ")", "as", "f", ":", "# When opening files via os, truncation must be done manually.", "f", ".", "truncate", "(", ")", "f", ".", "write", "(", "self", ".", "userId", "+", "\"\\n\"", ")", "f", ".", "write", "(", "self", ".", "tokens", "[", "\"skype\"", "]", "+", "\"\\n\"", ")", "f", ".", "write", "(", "str", "(", "int", "(", "time", ".", "mktime", "(", "self", ".", "tokenExpiry", "[", "\"skype\"", "]", ".", "timetuple", "(", ")", ")", ")", ")", "+", "\"\\n\"", ")", "f", ".", "write", "(", "self", ".", "tokens", "[", "\"reg\"", "]", "+", "\"\\n\"", ")", "f", ".", "write", "(", "str", "(", "int", "(", "time", ".", "mktime", "(", "self", ".", "tokenExpiry", "[", "\"reg\"", "]", ".", "timetuple", "(", ")", ")", ")", ")", "+", "\"\\n\"", ")", "f", ".", "write", "(", "self", ".", "msgsHost", "+", "\"\\n\"", ")" ]

[ "Store", "details", "of", "the", "current", "connection", "in", "the", "named", "file", "." ]

[ "def", "find_ws_name", "(", "wb", ",", "name", ")", ":", "if", "isinstance", "(", "wb", ",", "string_types", ")", ":", "# FIXME: importar o borrar segun corresponda", "wb", "=", "load_workbook", "(", "wb", ",", "read_only", "=", "True", ",", "data_only", "=", "True", ")", "for", "sheetname", "in", "wb", ".", "sheetnames", ":", "if", "sheetname", ".", "lower", "(", ")", "==", "name", ".", "lower", "(", ")", ":", "return", "sheetname", "raise", "Exception", "(", "\"No existe la hoja {}\"", ".", "format", "(", "name", ")", ")" ]

[ "Busca", "una", "hoja", "en", "un", "workbook", "sin", "importar", "mayúsculas", "/", "minúsculas", "." ]

[ "def", "compute", "(", "self", ",", "text", ",", "# text for which to find the most similar event", "lang", "=", "\"eng\"", ")", ":", "# language in which the text is written", "params", "=", "{", "\"lang\"", ":", "lang", ",", "\"text\"", ":", "text", ",", "\"topClustersCount\"", ":", "self", ".", "_nrOfEventsToReturn", "}", "res", "=", "self", ".", "_er", ".", "jsonRequest", "(", "\"/json/getEventForText/enqueueRequest\"", ",", "params", ")", "requestId", "=", "res", "[", "\"requestId\"", "]", "for", "i", "in", "range", "(", "10", ")", ":", "time", ".", "sleep", "(", "1", ")", "# sleep for 1 second to wait for the clustering to perform computation", "res", "=", "self", ".", "_er", ".", "jsonRequest", "(", "\"/json/getEventForText/testRequest\"", ",", "{", "\"requestId\"", ":", "requestId", "}", ")", "if", "isinstance", "(", "res", ",", "list", ")", "and", "len", "(", "res", ")", ">", "0", ":", "return", "res", "return", "None" ]

[ "compute", "the", "list", "of", "most", "similar", "events", "for", "the", "given", "text" ]

[ "def", "get_over_current", "(", "self", ",", "channel", ")", ":", "try", ":", "bit", "=", "self", ".", "_ch_map", "[", "channel", "]", "[", "'GPIOOC'", "]", "[", "'bit'", "]", "except", "KeyError", ":", "raise", "ValueError", "(", "'get_over_current() not supported for channel %s'", "%", "channel", ")", "return", "not", "self", ".", "_get_power_gpio_value", "(", "bit", ")" ]

[ "Reading", "over", "current", "status", "of", "power", "channel" ]

[ "def", "sfiles_to_event", "(", "sfile_list", ")", ":", "event_list", "=", "[", "]", "sort_list", "=", "[", "(", "readheader", "(", "sfile", ")", ".", "origins", "[", "0", "]", ".", "time", ",", "sfile", ")", "for", "sfile", "in", "sfile_list", "]", "sort_list", ".", "sort", "(", "key", "=", "lambda", "tup", ":", "tup", "[", "0", "]", ")", "sfile_list", "=", "[", "sfile", "[", "1", "]", "for", "sfile", "in", "sort_list", "]", "catalog", "=", "Catalog", "(", ")", "for", "i", ",", "sfile", "in", "enumerate", "(", "sfile_list", ")", ":", "event_list", ".", "append", "(", "(", "i", ",", "sfile", ")", ")", "catalog", ".", "append", "(", "readheader", "(", "sfile", ")", ")", "# Hand off to sister function", "write_event", "(", "catalog", ")", "return", "event_list" ]

[ "Write", "an", "event", ".", "dat", "file", "from", "a", "list", "of", "Seisan", "events" ]