Datasets:

---

kejian

/

codesearchnet-python-raw

like 1

[ "def", "fragment_search", "(", "self", ",", "fragement", ":", "str", ")", "->", "List", "[", "dict", "]", ":", "fragement", "=", "self", ".", "extract_fragment", "(", "fragement", ")", "ilx_rows", "=", "self", ".", "fragment2rows", ".", "get", "(", "fragement", ")", "if", "not", "ilx_rows", ":", "return", "None", "else", ":", "return", "ilx_rows" ]

[ "Returns", "the", "rows", "in", "InterLex", "associated", "with", "the", "fragment" ]

[ "def", "p_elseif_list", "(", "p", ")", ":", "if", "len", "(", "p", ")", "==", "2", ":", "p", "[", "0", "]", "=", "[", "]", "else", ":", "p", "[", "0", "]", "=", "p", "[", "1", "]", "+", "[", "ast", ".", "ElseIf", "(", "p", "[", "4", "]", ",", "p", "[", "6", "]", ",", "lineno", "=", "p", ".", "lineno", "(", "2", ")", ")", "]" ]

[ "elseif_list", ":", "empty", "|", "elseif_list", "ELSEIF", "LPAREN", "expr", "RPAREN", "statement" ]

[ "def", "set_monitored_resource_attributes", "(", "span", ")", ":", "resource", "=", "monitored_resource", ".", "get_instance", "(", ")", "if", "resource", "is", "not", "None", ":", "resource_type", "=", "resource", ".", "get_type", "(", ")", "resource_labels", "=", "resource", ".", "get_labels", "(", ")", "if", "resource_type", "==", "'gke_container'", ":", "resource_type", "=", "'k8s_container'", "set_attribute_label", "(", "span", ",", "resource_type", ",", "resource_labels", ",", "'project_id'", ")", "set_attribute_label", "(", "span", ",", "resource_type", ",", "resource_labels", ",", "'cluster_name'", ")", "set_attribute_label", "(", "span", ",", "resource_type", ",", "resource_labels", ",", "'container_name'", ")", "set_attribute_label", "(", "span", ",", "resource_type", ",", "resource_labels", ",", "'namespace_id'", ",", "'namespace_name'", ")", "set_attribute_label", "(", "span", ",", "resource_type", ",", "resource_labels", ",", "'pod_id'", ",", "'pod_name'", ")", "set_attribute_label", "(", "span", ",", "resource_type", ",", "resource_labels", ",", "'zone'", ",", "'location'", ")", "elif", "resource_type", "==", "'gce_instance'", ":", "set_attribute_label", "(", "span", ",", "resource_type", ",", "resource_labels", ",", "'project_id'", ")", "set_attribute_label", "(", "span", ",", "resource_type", ",", "resource_labels", ",", "'instance_id'", ")", "set_attribute_label", "(", "span", ",", "resource_type", ",", "resource_labels", ",", "'zone'", ")", "elif", "resource_type", "==", "'aws_ec2_instance'", ":", "set_attribute_label", "(", "span", ",", "resource_type", ",", "resource_labels", ",", "'aws_account'", ")", "set_attribute_label", "(", "span", ",", "resource_type", ",", "resource_labels", ",", "'instance_id'", ")", "set_attribute_label", "(", "span", ",", "resource_type", ",", "resource_labels", ",", "'region'", ",", "label_value_prefix", "=", "'aws:'", ")" ]

[ "Set", "labels", "to", "span", "that", "can", "be", "used", "for", "tracing", ".", ":", "param", "span", ":", "Span", "object" ]

[ "def", "libvlc_log_get_context", "(", "ctx", ")", ":", "f", "=", "_Cfunctions", ".", "get", "(", "'libvlc_log_get_context'", ",", "None", ")", "or", "_Cfunction", "(", "'libvlc_log_get_context'", ",", "(", "(", "1", ",", ")", ",", "(", "2", ",", ")", ",", "(", "2", ",", ")", ",", "(", "2", ",", ")", ",", ")", ",", "None", ",", "None", ",", "Log_ptr", ",", "ListPOINTER", "(", "ctypes", ".", "c_char_p", ")", ",", "ListPOINTER", "(", "ctypes", ".", "c_char_p", ")", ",", "ctypes", ".", "POINTER", "(", "ctypes", ".", "c_uint", ")", ")", "return", "f", "(", "ctx", ")" ]

[ "Gets", "debugging", "information", "about", "a", "log", "message", ":", "the", "name", "of", "the", "VLC", "module", "emitting", "the", "message", "and", "the", "message", "location", "within", "the", "source", "code", ".", "The", "returned", "module", "name", "and", "file", "name", "will", "be", "NULL", "if", "unknown", ".", "The", "returned", "line", "number", "will", "similarly", "be", "zero", "if", "unknown", "." ]

[ "def", "resolve", "(", "self", ",", "uri", "=", "None", ",", "*", "*", "parts", ")", ":", "if", "uri", ":", "result", "=", "self", ".", "__class__", "(", "urljoin", "(", "str", "(", "self", ")", ",", "str", "(", "uri", ")", ")", ")", "else", ":", "result", "=", "self", ".", "__class__", "(", "self", ")", "for", "part", ",", "value", "in", "parts", ".", "items", "(", ")", ":", "if", "part", "not", "in", "self", ".", "__all_parts__", ":", "raise", "TypeError", "(", "\"Unknown URI component: \"", "+", "part", ")", "setattr", "(", "result", ",", "part", ",", "value", ")", "return", "result" ]

[ "Attempt", "to", "resolve", "a", "new", "URI", "given", "an", "updated", "URI", "partial", "or", "complete", "." ]

[ "def", "_modify_new_lines", "(", "code_to_modify", ",", "offset", ",", "code_to_insert", ")", ":", "# There's a nice overview of co_lnotab in", "# https://github.com/python/cpython/blob/3.6/Objects/lnotab_notes.txt", "new_list", "=", "list", "(", "code_to_modify", ".", "co_lnotab", ")", "if", "not", "new_list", ":", "# Could happen on a lambda (in this case, a breakpoint in the lambda should fallback to", "# tracing).", "return", "None", "# As all numbers are relative, what we want is to hide the code we inserted in the previous line", "# (it should be the last thing right before we increment the line so that we have a line event", "# right after the inserted code).", "bytecode_delta", "=", "len", "(", "code_to_insert", ")", "byte_increments", "=", "code_to_modify", ".", "co_lnotab", "[", "0", ":", ":", "2", "]", "line_increments", "=", "code_to_modify", ".", "co_lnotab", "[", "1", ":", ":", "2", "]", "if", "offset", "==", "0", ":", "new_list", "[", "0", "]", "+=", "bytecode_delta", "else", ":", "addr", "=", "0", "it", "=", "zip", "(", "byte_increments", ",", "line_increments", ")", "for", "i", ",", "(", "byte_incr", ",", "_line_incr", ")", "in", "enumerate", "(", "it", ")", ":", "addr", "+=", "byte_incr", "if", "addr", "==", "offset", ":", "new_list", "[", "i", "*", "2", "]", "+=", "bytecode_delta", "break", "return", "bytes", "(", "new_list", ")" ]

[ "Update", "new", "lines", ":", "the", "bytecode", "inserted", "should", "be", "the", "last", "instruction", "of", "the", "previous", "line", ".", ":", "return", ":", "bytes", "sequence", "of", "code", "with", "updated", "lines", "offsets" ]

[ "def", "run", "(", "self", ",", "raw_args", ")", ":", "parser", "=", "self", ".", "parser", "args", ",", "kwargs", "=", "parser", ".", "parse_callback_args", "(", "raw_args", ")", "callback", "=", "kwargs", ".", "pop", "(", "\"main_callback\"", ")", "if", "parser", ".", "has_injected_quiet", "(", ")", ":", "levels", "=", "kwargs", ".", "pop", "(", "\"quiet_inject\"", ",", "\"\"", ")", "logging", ".", "inject_quiet", "(", "levels", ")", "try", ":", "ret_code", "=", "callback", "(", "*", "args", ",", "*", "*", "kwargs", ")", "ret_code", "=", "int", "(", "ret_code", ")", "if", "ret_code", "else", "0", "except", "ArgError", "as", "e", ":", "# https://hg.python.org/cpython/file/2.7/Lib/argparse.py#l2374", "echo", ".", "err", "(", "\"{}: error: {}\"", ",", "parser", ".", "prog", ",", "str", "(", "e", ")", ")", "ret_code", "=", "2", "return", "ret_code" ]

[ "parse", "and", "import", "the", "script", "and", "then", "run", "the", "script", "s", "main", "function" ]

[ "def", "get_view_name", "(", "self", ")", ":", "func", "=", "self", ".", "settings", ".", "VIEW_NAME_FUNCTION", "return", "func", "(", "self", ".", "__class__", ",", "getattr", "(", "self", ",", "'suffix'", ",", "None", ")", ")" ]

[ "Return", "the", "view", "name", "as", "used", "in", "OPTIONS", "responses", "and", "in", "the", "browsable", "API", "." ]

[ "def", "check", "(", "self", ",", "url_data", ")", ":", "location", "=", "get_location", "(", "url_data", ".", "host", ")", "if", "location", ":", "url_data", ".", "add_info", "(", "_", "(", "\"URL is located in %(location)s.\"", ")", "%", "{", "\"location\"", ":", "_", "(", "location", ")", "}", ")" ]

[ "Try", "to", "ask", "GeoIP", "database", "for", "country", "info", "." ]

[ "def", "_hash", "(", "self", ",", "hash_name", ")", ":", "m", "=", "hashlib", ".", "new", "(", "hash_name", ")", "for", "chunk", "in", "self", ".", "chunks", "(", "8192", ",", "mode", "=", "\"rb\"", ")", ":", "m", ".", "update", "(", "chunk", ")", "return", "m" ]

[ "Returns", "a", "hash", "object", "for", "the", "file", "at", "the", "current", "path", "." ]

[ "def", "xisabs", "(", "filename", ")", ":", "if", "filename", ".", "startswith", "(", "b'/'", ")", ":", "# Linux/Unix", "return", "True", "elif", "filename", ".", "startswith", "(", "b'\\\\'", ")", ":", "# Windows", "return", "True", "elif", "re", ".", "match", "(", "b'\\\\w:[\\\\\\\\/]'", ",", "filename", ")", ":", "# Windows", "return", "True", "return", "False" ]

[ "Cross", "-", "platform", "version", "of", "os", ".", "path", ".", "isabs", "()", "Returns", "True", "if", "filename", "is", "absolute", "on", "Linux", "OS", "X", "or", "Windows", "." ]

[ "def", "handle_error", "(", "self", ",", "error", "=", "None", ")", ":", "if", "_debug", ":", "TCPServerActor", ".", "_debug", "(", "\"handle_error %r\"", ",", "error", ")", "# pass along to the director", "if", "error", "is", "not", "None", ":", "self", ".", "director", ".", "actor_error", "(", "self", ",", "error", ")", "else", ":", "TCPServer", ".", "handle_error", "(", "self", ")" ]

[ "Trap", "for", "TCPServer", "errors", "otherwise", "continue", "." ]

[ "def", "save", "(", "self", ",", "internal", "=", "False", ",", "meta", "=", "None", ",", "index_fields", "=", "None", ")", ":", "for", "f", "in", "self", ".", "on_save", ":", "f", "(", "self", ")", "if", "not", "(", "internal", "or", "self", ".", "_pre_save_hook_called", ")", ":", "self", ".", "_pre_save_hook_called", "=", "True", "self", ".", "pre_save", "(", ")", "if", "not", "self", ".", "deleted", ":", "self", ".", "_handle_uniqueness", "(", ")", "if", "not", "self", ".", "exist", ":", "self", ".", "pre_creation", "(", ")", "old_data", "=", "self", ".", "_data", ".", "copy", "(", ")", "if", "self", ".", "just_created", "is", "None", ":", "self", ".", "setattrs", "(", "just_created", "=", "not", "self", ".", "exist", ")", "if", "self", ".", "_just_created", "is", "None", ":", "self", ".", "setattrs", "(", "_just_created", "=", "self", ".", "just_created", ")", "self", ".", "objects", ".", "save_model", "(", "self", ",", "meta_data", "=", "meta", ",", "index_fields", "=", "index_fields", ")", "self", ".", "_handle_changed_fields", "(", "old_data", ")", "self", ".", "_process_relations", "(", "internal", ")", "if", "not", "(", "internal", "or", "self", ".", "_post_save_hook_called", ")", ":", "self", ".", "_post_save_hook_called", "=", "True", "self", ".", "post_save", "(", ")", "if", "self", ".", "_just_created", ":", "self", ".", "setattrs", "(", "just_created", "=", "self", ".", "_just_created", ",", "_just_created", "=", "False", ")", "self", ".", "post_creation", "(", ")", "self", ".", "_pre_save_hook_called", "=", "False", "self", ".", "_post_save_hook_called", "=", "False", "if", "not", "internal", ":", "self", ".", "_initial_data", "=", "self", ".", "clean_value", "(", ")", "return", "self" ]

[ "Save", "s", "object", "to", "DB", "." ]

[ "def", "verify_day", "(", "self", ",", "now", ")", ":", "return", "self", ".", "day", "==", "\"*\"", "or", "str", "(", "now", ".", "day", ")", "in", "self", ".", "day", ".", "split", "(", "\" \"", ")" ]

[ "Verify", "the", "day" ]

[ "def", "decorate_with_checker", "(", "func", ":", "CallableT", ")", "->", "CallableT", ":", "assert", "not", "hasattr", "(", "func", ",", "\"__preconditions__\"", ")", ",", "\"Expected func to have no list of preconditions (there should be only a single contract checker per function).\"", "assert", "not", "hasattr", "(", "func", ",", "\"__postconditions__\"", ")", ",", "\"Expected func to have no list of postconditions (there should be only a single contract checker per function).\"", "assert", "not", "hasattr", "(", "func", ",", "\"__postcondition_snapshots__\"", ")", ",", "\"Expected func to have no list of postcondition snapshots (there should be only a single contract checker \"", "\"per function).\"", "sign", "=", "inspect", ".", "signature", "(", "func", ")", "param_names", "=", "list", "(", "sign", ".", "parameters", ".", "keys", "(", ")", ")", "# Determine the default argument values.", "kwdefaults", "=", "dict", "(", ")", "# type: Dict[str, Any]", "# Add to the defaults all the values that are needed by the contracts.", "for", "param", "in", "sign", ".", "parameters", ".", "values", "(", ")", ":", "if", "param", ".", "default", "!=", "inspect", ".", "Parameter", ".", "empty", ":", "kwdefaults", "[", "param", ".", "name", "]", "=", "param", ".", "default", "def", "wrapper", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "\"\"\"Wrap func by checking the preconditions and postconditions.\"\"\"", "preconditions", "=", "getattr", "(", "wrapper", ",", "\"__preconditions__\"", ")", "# type: List[List[Contract]]", "snapshots", "=", "getattr", "(", "wrapper", ",", "\"__postcondition_snapshots__\"", ")", "# type: List[Snapshot]", "postconditions", "=", "getattr", "(", "wrapper", ",", "\"__postconditions__\"", ")", "# type: List[Contract]", "resolved_kwargs", "=", "_kwargs_from_call", "(", "param_names", "=", "param_names", ",", "kwdefaults", "=", "kwdefaults", ",", "args", "=", "args", ",", "kwargs", "=", "kwargs", ")", "if", "postconditions", ":", "if", "'result'", "in", "resolved_kwargs", ":", "raise", "TypeError", "(", "\"Unexpected argument 'result' in a function decorated with postconditions.\"", ")", "if", "'OLD'", "in", "resolved_kwargs", ":", "raise", "TypeError", "(", "\"Unexpected argument 'OLD' in a function decorated with postconditions.\"", ")", "# Assert the preconditions in groups. This is necessary to implement \"require else\" logic when a class", "# weakens the preconditions of its base class.", "violation_err", "=", "None", "# type: Optional[ViolationError]", "for", "group", "in", "preconditions", ":", "violation_err", "=", "None", "try", ":", "for", "contract", "in", "group", ":", "_assert_precondition", "(", "contract", "=", "contract", ",", "resolved_kwargs", "=", "resolved_kwargs", ")", "break", "except", "ViolationError", "as", "err", ":", "violation_err", "=", "err", "if", "violation_err", "is", "not", "None", ":", "raise", "violation_err", "# pylint: disable=raising-bad-type", "# Capture the snapshots", "if", "postconditions", ":", "old_as_mapping", "=", "dict", "(", ")", "# type: MutableMapping[str, Any]", "for", "snap", "in", "snapshots", ":", "# This assert is just a last defense.", "# Conflicting snapshot names should have been caught before, either during the decoration or", "# in the meta-class.", "assert", "snap", ".", "name", "not", "in", "old_as_mapping", ",", "\"Snapshots with the conflicting name: {}\"", "old_as_mapping", "[", "snap", ".", "name", "]", "=", "_capture_snapshot", "(", "a_snapshot", "=", "snap", ",", "resolved_kwargs", "=", "resolved_kwargs", ")", "resolved_kwargs", "[", "'OLD'", "]", "=", "_Old", "(", "mapping", "=", "old_as_mapping", ")", "# Execute the wrapped function", "result", "=", "func", "(", "*", "args", ",", "*", "*", "kwargs", ")", "if", "postconditions", ":", "resolved_kwargs", "[", "'result'", "]", "=", "result", "# Assert the postconditions as a conjunction", "for", "contract", "in", "postconditions", ":", "_assert_postcondition", "(", "contract", "=", "contract", ",", "resolved_kwargs", "=", "resolved_kwargs", ")", "return", "result", "# type: ignore", "# Copy __doc__ and other properties so that doctests can run", "functools", ".", "update_wrapper", "(", "wrapper", "=", "wrapper", ",", "wrapped", "=", "func", ")", "assert", "not", "hasattr", "(", "wrapper", ",", "\"__preconditions__\"", ")", ",", "\"Expected no preconditions set on a pristine contract checker.\"", "assert", "not", "hasattr", "(", "wrapper", ",", "\"__postcondition_snapshots__\"", ")", ",", "\"Expected no postcondition snapshots set on a pristine contract checker.\"", "assert", "not", "hasattr", "(", "wrapper", ",", "\"__postconditions__\"", ")", ",", "\"Expected no postconditions set on a pristine contract checker.\"", "# Precondition is a list of condition groups (i.e. disjunctive normal form):", "# each group consists of AND'ed preconditions, while the groups are OR'ed.", "#", "# This is necessary in order to implement \"require else\" logic when a class weakens the preconditions of", "# its base class.", "setattr", "(", "wrapper", ",", "\"__preconditions__\"", ",", "[", "]", ")", "setattr", "(", "wrapper", ",", "\"__postcondition_snapshots__\"", ",", "[", "]", ")", "setattr", "(", "wrapper", ",", "\"__postconditions__\"", ",", "[", "]", ")", "return", "wrapper" ]

[ "Decorate", "the", "function", "with", "a", "checker", "that", "verifies", "the", "preconditions", "and", "postconditions", "." ]

[ "def", "create_dsmr_reader", "(", "port", ",", "dsmr_version", ",", "telegram_callback", ",", "loop", "=", "None", ")", ":", "protocol", ",", "serial_settings", "=", "create_dsmr_protocol", "(", "dsmr_version", ",", "telegram_callback", ",", "loop", "=", "None", ")", "serial_settings", "[", "'url'", "]", "=", "port", "conn", "=", "create_serial_connection", "(", "loop", ",", "protocol", ",", "*", "*", "serial_settings", ")", "return", "conn" ]

[ "Creates", "a", "DSMR", "asyncio", "protocol", "coroutine", "using", "serial", "port", "." ]

[ "def", "get_by_id", "(", "self", ",", "id", ")", ":", "for", "child", "in", "self", ".", "children", ":", "if", "child", "[", "self", ".", "child_id_attribute", "]", "==", "id", ":", "return", "child", "else", ":", "continue", "return", "None" ]

[ "Return", "object", "based", "on", "child_id_attribute", "." ]

[ "def", "parse_value", "(", "source", ":", "SourceType", ",", "*", "*", "options", ":", "dict", ")", "->", "ValueNode", ":", "if", "isinstance", "(", "source", ",", "str", ")", ":", "source", "=", "Source", "(", "source", ")", "lexer", "=", "Lexer", "(", "source", ",", "*", "*", "options", ")", "expect_token", "(", "lexer", ",", "TokenKind", ".", "SOF", ")", "value", "=", "parse_value_literal", "(", "lexer", ",", "False", ")", "expect_token", "(", "lexer", ",", "TokenKind", ".", "EOF", ")", "return", "value" ]

[ "Parse", "the", "AST", "for", "a", "given", "string", "containing", "a", "GraphQL", "value", "." ]

[ "def", "get", "(", "self", ",", "uri", ")", ":", "cache_key", "=", "self", ".", "_build_cache_key", "(", "uri", ")", "value", "=", "self", ".", "_get", "(", "cache_key", ")", "if", "value", "is", "not", "None", ":", "return", "self", ".", "_decode_node", "(", "uri", ",", "value", ")" ]

[ "Return", "node", "for", "uri", "or", "None", "if", "not", "exists", ":", "{", "uri", ":", "x", "content", ":", "y", "}" ]

[ "def", "set_action", "(", "self", ",", "action", ",", "message", ")", ":", "self", ".", "extra_data", "[", "\"_action\"", "]", "=", "action", "self", ".", "extra_data", "[", "\"_message\"", "]", "=", "message" ]

[ "Set", "the", "action", "to", "be", "taken", "for", "this", "object", "." ]

[ "def", "verify", "(", "self", ",", "email", ")", ":", "resp", "=", "self", ".", "_call", "(", "endpoint", "=", "'single'", ",", "data", "=", "{", "'email'", ":", "email", "}", ")", "return", "VerifiedEmail", "(", "email", ",", "resp", "[", "'result'", "]", ")" ]

[ "Verify", "a", "single", "email", "address", ".", ":", "param", "str", "email", ":", "Email", "address", "to", "verify", ".", ":", "return", ":", "A", "VerifiedEmail", "object", "." ]

[ "def", "get_user_id", "(", "self", ",", "mxit_id", ",", "scope", "=", "'profile/public'", ")", ":", "user_id", "=", "_get", "(", "token", "=", "self", ".", "oauth", ".", "get_app_token", "(", "scope", ")", ",", "uri", "=", "'/user/lookup/'", "+", "urllib", ".", "quote", "(", "mxit_id", ")", ")", "if", "user_id", ".", "startswith", "(", "'\"'", ")", "and", "user_id", ".", "endswith", "(", "'\"'", ")", ":", "user_id", "=", "user_id", "[", "1", ":", "-", "1", "]", "return", "user_id" ]

[ "Retrieve", "the", "Mxit", "user", "s", "internal", "user", "ID", "No", "user", "authentication", "required" ]

[ "def", "_combine_sparse_successor", "(", "parent_indices", ",", "parent_shape", ",", "child_indices", ",", "child_values", ",", "child_shape", ",", "name", "=", "None", ")", ":", "with", "ops", ".", "name_scope", "(", "name", ",", "\"CombineSparseSuccessor\"", ",", "[", "parent_indices", ",", "parent_shape", ",", "child_indices", ",", "child_values", ",", "child_shape", "]", ")", ":", "indices", ",", "values", ",", "shape", "=", "ops_module", ".", "combine_sparse_successor", "(", "parent_indices", ",", "parent_shape", ",", "child_indices", ",", "child_values", ",", "child_shape", ")", "return", "tf", ".", "SparseTensor", "(", "indices", "=", "indices", ",", "values", "=", "values", ",", "dense_shape", "=", "shape", ")" ]

[ "Combines", "two", "string", "SparseTensor", "s", "where", "second", "SparseTensor", "is", "the", "result", "of", "expanding", "first", "SparseTensor", "s", "values", "." ]

[ "def", "nStepsForParam", "(", "self", ",", "param", ")", ":", "if", "param", "[", "'parameter'", "]", "==", "'filename'", ":", "return", "len", "(", "param", "[", "'names'", "]", ")", "else", ":", "if", "param", "[", "'step'", "]", ">", "0", ":", "if", "abs", "(", "param", "[", "'start'", "]", "-", "param", "[", "'stop'", "]", ")", "<", "param", "[", "'step'", "]", ":", "return", "0", "# print 'range', param['start'] - param['stop']", "nsteps", "=", "np", ".", "around", "(", "abs", "(", "param", "[", "'start'", "]", "-", "param", "[", "'stop'", "]", ")", ",", "4", ")", "/", "float", "(", "param", "[", "'step'", "]", ")", "nsteps", "=", "int", "(", "np", ".", "ceil", "(", "nsteps", ")", "+", "1", ")", "elif", "param", "[", "'start'", "]", "==", "param", "[", "'stop'", "]", ":", "nsteps", "=", "1", "else", ":", "nsteps", "=", "0", "return", "nsteps" ]

[ "Gets", "the", "number", "of", "steps", "*", "parameter", "*", "will", "yeild" ]

[ "def", "macros_attachment_show", "(", "self", ",", "id", ",", "*", "*", "kwargs", ")", ":", "api_path", "=", "\"/api/v2/macros/attachments/{id}.json\"", "api_path", "=", "api_path", ".", "format", "(", "id", "=", "id", ")", "return", "self", ".", "call", "(", "api_path", ",", "*", "*", "kwargs", ")" ]

[ "https", ":", "//", "developer", ".", "zendesk", ".", "com", "/", "rest_api", "/", "docs", "/", "core", "/", "macros#show", "-", "macro", "-", "attachment" ]

[ "def", "_validate_type", "(", "self", ",", "file_name", ",", "extension_map", ",", "method_title", ",", "argument_title", ")", ":", "# validate file extension\r", "from", "labpack", ".", "parsing", ".", "regex", "import", "labRegex", "file_extension", "=", "''", "ext_types", "=", "labRegex", "(", "extension_map", ")", "file_mapping", "=", "ext_types", ".", "map", "(", "file_name", ")", "[", "0", "]", "extension_list", "=", "[", "]", "for", "key", ",", "value", "in", "file_mapping", ".", "items", "(", ")", ":", "if", "isinstance", "(", "value", ",", "bool", ")", ":", "extension_list", ".", "append", "(", "'.%s'", "%", "key", ")", "if", "value", "and", "isinstance", "(", "value", ",", "bool", ")", ":", "file_extension", "=", "'.%s'", "+", "key", "if", "not", "file_extension", ":", "raise", "ValueError", "(", "'%s(%s=%s) must be one of %s file types.'", "%", "(", "method_title", ",", "argument_title", ",", "file_name", ",", "extension_list", ")", ")", "return", "file_extension" ]

[ "a", "helper", "method", "to", "validate", "extension", "type", "of", "file", ":", "param", "file_name", ":", "string", "with", "file", "name", "to", "test", ":", "param", "extension_map", ":", "dictionary", "with", "extensions", "names", "and", "regex", "patterns", ":", "param", "method_title", ":", "string", "with", "title", "of", "feeder", "method", ":", "param", "argument_title", ":", "string", "with", "title", "of", "argument", "key", "from", "feeder", "method", ":", "return", ":", "string", "with", "file", "extension" ]

[ "def", "read", "(", "self", ")", ":", "data", "=", "None", "while", "True", ":", "last_offset", "=", "self", ".", "tell", "(", ")", "try", ":", "(", "chunk", ",", "record_type", ")", "=", "self", ".", "__try_read_record", "(", ")", "if", "record_type", "==", "_RECORD_TYPE_NONE", ":", "self", ".", "__sync", "(", ")", "elif", "record_type", "==", "_RECORD_TYPE_FULL", ":", "if", "data", "is", "not", "None", ":", "logging", ".", "warning", "(", "\"Ordering corruption: Got FULL record while already \"", "\"in a chunk at offset %d\"", ",", "last_offset", ")", "return", "chunk", "elif", "record_type", "==", "_RECORD_TYPE_FIRST", ":", "if", "data", "is", "not", "None", ":", "logging", ".", "warning", "(", "\"Ordering corruption: Got FIRST record while already \"", "\"in a chunk at offset %d\"", ",", "last_offset", ")", "data", "=", "chunk", "elif", "record_type", "==", "_RECORD_TYPE_MIDDLE", ":", "if", "data", "is", "None", ":", "logging", ".", "warning", "(", "\"Ordering corruption: Got MIDDLE record before FIRST \"", "\"record at offset %d\"", ",", "last_offset", ")", "else", ":", "data", "+=", "chunk", "elif", "record_type", "==", "_RECORD_TYPE_LAST", ":", "if", "data", "is", "None", ":", "logging", ".", "warning", "(", "\"Ordering corruption: Got LAST record but no chunk is in \"", "\"progress at offset %d\"", ",", "last_offset", ")", "else", ":", "result", "=", "data", "+", "chunk", "data", "=", "None", "return", "result", "else", ":", "raise", "errors", ".", "InvalidRecordError", "(", "\"Unsupported record type: %s\"", "%", "record_type", ")", "except", "errors", ".", "InvalidRecordError", ",", "e", ":", "logging", ".", "warning", "(", "\"Invalid record encountered at %s (%s). Syncing to \"", "\"the next block\"", ",", "last_offset", ",", "e", ")", "data", "=", "None", "self", ".", "__sync", "(", ")" ]

[ "Reads", "record", "from", "current", "position", "in", "reader", "." ]

[ "def", "is_user_already_locked", "(", "username", ")", ":", "if", "username", "is", "None", ":", "return", "False", "if", "config", ".", "DISABLE_USERNAME_LOCKOUT", ":", "return", "False", "return", "REDIS_SERVER", ".", "get", "(", "get_username_blocked_cache_key", "(", "username", ")", ")" ]

[ "Is", "this", "username", "already", "locked?" ]

[ "def", "_column_pack_filter", "(", "self", ",", "next_filter", ")", ":", "next", "(", "next_filter", ")", "col_count", "=", "len", "(", "self", ".", "widths", ")", "queues", "=", "[", "collections", ".", "deque", "(", ")", "for", "_", "in", "range", "(", "col_count", ")", "]", "while", "True", ":", "try", ":", "row", "=", "(", "yield", ")", "except", "GeneratorExit", ":", "break", "for", "col", ",", "queue", "in", "zip", "(", "row", ",", "queues", ")", ":", "if", "col", "is", "not", "None", ":", "queue", ".", "append", "(", "col", ")", "if", "all", "(", "queues", ")", ":", "next_filter", ".", "send", "(", "[", "x", ".", "popleft", "(", ")", "for", "x", "in", "queues", "]", ")", "blanks", "=", "list", "(", "map", "(", "self", ".", "_get_blank_cell", ",", "range", "(", "col_count", ")", ")", ")", "while", "any", "(", "queues", ")", ":", "next_filter", ".", "send", "(", "[", "q", ".", "popleft", "(", ")", "if", "q", "else", "blank", "for", "q", ",", "blank", "in", "zip", "(", "queues", ",", "blanks", ")", "]", ")" ]

[ "Top", "-", "align", "column", "data", "irrespective", "of", "original", "row", "alignment", ".", "E", ".", "g", ".", "INPUT", ":", "[", "[", "1a", "2a", "]", "[", "None", "2b", "]", "[", "1b", "2c", "]", "[", "None", "2d", "]", "]", "OUTPUT", ":", "[", "[", "1a", "2a", "]", "[", "1b", "2b", "]", "[", "<blank", ">", "2c", "]", "[", "<blank", ">", "2d", "]", "]" ]

[ "def", "convert_string_to_type", "(", "string_value", ")", ":", "# If the parameter is already a type, return it", "if", "string_value", "in", "[", "'None'", ",", "type", "(", "None", ")", ".", "__name__", "]", ":", "return", "type", "(", "None", ")", "if", "isinstance", "(", "string_value", ",", "type", ")", "or", "isclass", "(", "string_value", ")", ":", "return", "string_value", "# Get object associated with string", "# First check whether we are having a built in type (int, str, etc)", "if", "sys", ".", "version_info", ">=", "(", "3", ",", ")", ":", "import", "builtins", "as", "builtins23", "else", ":", "import", "__builtin__", "as", "builtins23", "if", "hasattr", "(", "builtins23", ",", "string_value", ")", ":", "obj", "=", "getattr", "(", "builtins23", ",", "string_value", ")", "if", "type", "(", "obj", ")", "is", "type", ":", "return", "obj", "# If not, try to locate the module", "try", ":", "obj", "=", "locate", "(", "string_value", ")", "except", "ErrorDuringImport", "as", "e", ":", "raise", "ValueError", "(", "\"Unknown type '{0}'\"", ".", "format", "(", "e", ")", ")", "# Check whether object is a type", "if", "type", "(", "obj", ")", "is", "type", ":", "return", "locate", "(", "string_value", ")", "# Check whether object is a class", "if", "isclass", "(", "obj", ")", ":", "return", "obj", "# Raise error if none is the case", "raise", "ValueError", "(", "\"Unknown type '{0}'\"", ".", "format", "(", "string_value", ")", ")" ]

[ "Converts", "a", "string", "into", "a", "type", "or", "class" ]

[ "def", "draw", "(", "self", ")", ":", "indices", "=", "np", ".", "arange", "(", "len", "(", "self", ".", "classes_", ")", ")", "prev", "=", "np", ".", "zeros", "(", "len", "(", "self", ".", "classes_", ")", ")", "colors", "=", "resolve_colors", "(", "colors", "=", "self", ".", "colors", ",", "n_colors", "=", "len", "(", "self", ".", "classes_", ")", ")", "for", "idx", ",", "row", "in", "enumerate", "(", "self", ".", "predictions_", ")", ":", "self", ".", "ax", ".", "bar", "(", "indices", ",", "row", ",", "label", "=", "self", ".", "classes_", "[", "idx", "]", ",", "bottom", "=", "prev", ",", "color", "=", "colors", "[", "idx", "]", ")", "prev", "+=", "row", "return", "self", ".", "ax" ]

[ "Renders", "the", "class", "prediction", "error", "across", "the", "axis", "." ]

[ "def", "annotate_metadata_code", "(", "repo", ",", "files", ")", ":", "package", "=", "repo", ".", "package", "package", "[", "'code'", "]", "=", "[", "]", "for", "p", "in", "files", ":", "matching_files", "=", "glob2", ".", "glob", "(", "\"**/{}\"", ".", "format", "(", "p", ")", ")", "for", "f", "in", "matching_files", ":", "absf", "=", "os", ".", "path", ".", "abspath", "(", "f", ")", "print", "(", "\"Add commit data for {}\"", ".", "format", "(", "f", ")", ")", "package", "[", "'code'", "]", ".", "append", "(", "OrderedDict", "(", "[", "(", "'script'", ",", "f", ")", ",", "(", "'permalink'", ",", "repo", ".", "manager", ".", "permalink", "(", "repo", ",", "absf", ")", ")", ",", "(", "'mimetypes'", ",", "mimetypes", ".", "guess_type", "(", "absf", ")", "[", "0", "]", ")", ",", "(", "'sha256'", ",", "compute_sha256", "(", "absf", ")", ")", "]", ")", ")" ]

[ "Update", "metadata", "with", "the", "commit", "information" ]

[ "def", "import_tree_order_from_file", "(", "self", ",", "MyOrganismDB", ",", "filename", ")", ":", "tree_order", "=", "[", "acc", ".", "strip", "(", ")", "for", "acc", "in", "open", "(", "filename", ")", "]", "#print tree_order", "for", "org", "in", "MyOrganismDB", ".", "organisms", ":", "for", "tree_accession", "in", "tree_order", ":", "#print tree_accession", "if", "org", ".", "accession", "==", "tree_accession", ":", "org", ".", "tree_order", "=", "tree_order", ".", "index", "(", "tree_accession", ")" ]

[ "Import", "the", "accession", "list", "that", "has", "been", "ordered", "by", "position", "in", "a", "phylogenetic", "tree", ".", "Get", "the", "index", "in", "the", "list", "and", "add", "this", "to", "the", "Organism", "object", ".", "Later", "we", "can", "use", "this", "position", "to", "make", "a", "heatmap", "that", "matches", "up", "to", "a", "phylogenetic", "tree", "." ]

[ "def", "import_users", "(", "path", ",", "resource_name", "=", "None", ",", "send_email_to_user", "=", "None", ",", "alternate_email", "=", "None", ",", "verbose", "=", "None", ",", "export_to_file", "=", "None", ",", "*", "*", "kwargs", ",", ")", ":", "users", "=", "[", "]", "with", "open", "(", "path", ")", "as", "f", ":", "reader", "=", "csv", ".", "DictReader", "(", "f", ")", "for", "user_data", "in", "reader", ":", "username", "=", "user_data", ".", "get", "(", "\"username\"", ")", "site_names", "=", "user_data", ".", "get", "(", "\"sites\"", ")", ".", "lower", "(", ")", ".", "split", "(", "\",\"", ")", "group_names", "=", "user_data", ".", "get", "(", "\"groups\"", ")", ".", "lower", "(", ")", ".", "split", "(", "\",\"", ")", "first_name", "=", "user_data", ".", "get", "(", "\"first_name\"", ")", "last_name", "=", "user_data", ".", "get", "(", "\"last_name\"", ")", "email", "=", "user_data", ".", "get", "(", "\"email\"", ")", "o", "=", "UserImporter", "(", "username", "=", "username", ",", "first_name", "=", "first_name", ",", "last_name", "=", "last_name", ",", "email", "=", "email", ",", "site_names", "=", "site_names", ",", "group_names", "=", "group_names", ",", "resource_name", "=", "resource_name", ",", "send_email_to_user", "=", "send_email_to_user", ",", "alternate_email", "=", "alternate_email", ",", "verbose", "=", "verbose", ",", "*", "*", "kwargs", ",", ")", "users", ".", "append", "(", "{", "\"username\"", ":", "o", ".", "user", ".", "username", ",", "\"password\"", ":", "o", ".", "password", ",", "\"first_name\"", ":", "o", ".", "user", ".", "first_name", ",", "\"last_name\"", ":", "o", ".", "user", ".", "last_name", ",", "\"sites\"", ":", "o", ".", "site_names", ",", "\"groups\"", ":", "o", ".", "group_names", ",", "}", ")", "if", "export_to_file", ":", "fieldnames", "=", "[", "\"username\"", ",", "\"password\"", ",", "\"first_name\"", ",", "\"last_name\"", ",", "\"sites\"", ",", "\"groups\"", ",", "]", "with", "open", "(", "path", "+", "\"new.csv\"", ",", "\"w+\"", ")", "as", "f", ":", "writer", "=", "csv", ".", "DictWriter", "(", "f", ",", "fieldnames", "=", "fieldnames", ")", "writer", ".", "writeheader", "(", ")", "for", "user", "in", "users", ":", "writer", ".", "writerow", "(", "user", ")" ]

[ "Import", "users", "from", "a", "CSV", "file", "with", "columns", ":", "username", "first_name", "last_name", "email", "sites", ":", "a", "comma", "-", "separated", "list", "of", "sites", "groups", ":", "a", "comma", "-", "separated", "list", "of", "groups", "job_title" ]

[ "def", "spec_trace", "(", "traces", ",", "cmap", "=", "None", ",", "wlen", "=", "0.4", ",", "log", "=", "False", ",", "trc", "=", "'k'", ",", "tralpha", "=", "0.9", ",", "size", "=", "(", "10", ",", "13", ")", ",", "fig", "=", "None", ",", "*", "*", "kwargs", ")", ":", "import", "matplotlib", ".", "pyplot", "as", "plt", "if", "isinstance", "(", "traces", ",", "Stream", ")", ":", "traces", ".", "sort", "(", "[", "'station'", ",", "'channel'", "]", ")", "if", "not", "fig", ":", "fig", "=", "plt", ".", "figure", "(", ")", "for", "i", ",", "tr", "in", "enumerate", "(", "traces", ")", ":", "if", "i", "==", "0", ":", "ax", "=", "fig", ".", "add_subplot", "(", "len", "(", "traces", ")", ",", "1", ",", "i", "+", "1", ")", "else", ":", "ax", "=", "fig", ".", "add_subplot", "(", "len", "(", "traces", ")", ",", "1", ",", "i", "+", "1", ",", "sharex", "=", "ax", ")", "ax1", ",", "ax2", "=", "_spec_trace", "(", "tr", ",", "cmap", "=", "cmap", ",", "wlen", "=", "wlen", ",", "log", "=", "log", ",", "trc", "=", "trc", ",", "tralpha", "=", "tralpha", ",", "axes", "=", "ax", ")", "ax", ".", "set_yticks", "(", "[", "]", ")", "if", "i", "<", "len", "(", "traces", ")", "-", "1", ":", "plt", ".", "setp", "(", "ax1", ".", "get_xticklabels", "(", ")", ",", "visible", "=", "False", ")", "if", "isinstance", "(", "traces", ",", "list", ")", ":", "ax", ".", "text", "(", "0.005", ",", "0.85", ",", "\"{0}::{1}\"", ".", "format", "(", "tr", ".", "id", ",", "tr", ".", "stats", ".", "starttime", ")", ",", "bbox", "=", "dict", "(", "facecolor", "=", "'white'", ",", "alpha", "=", "0.8", ")", ",", "transform", "=", "ax2", ".", "transAxes", ")", "elif", "isinstance", "(", "traces", ",", "Stream", ")", ":", "ax", ".", "text", "(", "0.005", ",", "0.85", ",", "tr", ".", "id", ",", "bbox", "=", "dict", "(", "facecolor", "=", "'white'", ",", "alpha", "=", "0.8", ")", ",", "transform", "=", "ax2", ".", "transAxes", ")", "ax", ".", "text", "(", "0.005", ",", "0.02", ",", "str", "(", "np", ".", "max", "(", "tr", ".", "data", ")", ".", "round", "(", "1", ")", ")", ",", "bbox", "=", "dict", "(", "facecolor", "=", "'white'", ",", "alpha", "=", "0.95", ")", ",", "transform", "=", "ax2", ".", "transAxes", ")", "ax", ".", "set_xlabel", "(", "'Time (s)'", ")", "fig", ".", "subplots_adjust", "(", "hspace", "=", "0", ")", "fig", ".", "set_size_inches", "(", "w", "=", "size", "[", "0", "]", ",", "h", "=", "size", "[", "1", "]", ",", "forward", "=", "True", ")", "fig", ".", "text", "(", "0.04", ",", "0.5", ",", "'Frequency (Hz)'", ",", "va", "=", "'center'", ",", "rotation", "=", "'vertical'", ")", "fig", "=", "_finalise_figure", "(", "fig", "=", "fig", ",", "*", "*", "kwargs", ")", "# pragma: no cover", "return", "fig" ]

[ "Plots", "seismic", "data", "with", "spectrogram", "behind", "." ]

[ "def", "request_check_all", "(", "self", ",", "wait_time", "=", "5", ")", ":", "with", "self", ".", "_lock", ":", "self", ".", "_request_check_all", "(", ")", "self", ".", "_condition", ".", "wait", "(", "wait_time", ")" ]

[ "Wake", "all", "monitors", "wait", "for", "at", "least", "one", "to", "check", "its", "server", "." ]

[ "def", "check_for_lane_permission", "(", "self", ")", ":", "# TODO: Cache lane_data in app memory", "if", "self", ".", "current", ".", "lane_permission", ":", "log", ".", "debug", "(", "\"HAS LANE PERM: %s\"", "%", "self", ".", "current", ".", "lane_permission", ")", "perm", "=", "self", ".", "current", ".", "lane_permission", "if", "not", "self", ".", "current", ".", "has_permission", "(", "perm", ")", ":", "raise", "HTTPError", "(", "403", ",", "\"You don't have required lane permission: %s\"", "%", "perm", ")", "if", "self", ".", "current", ".", "lane_relations", ":", "context", "=", "self", ".", "get_pool_context", "(", ")", "log", ".", "debug", "(", "\"HAS LANE RELS: %s\"", "%", "self", ".", "current", ".", "lane_relations", ")", "try", ":", "cond_result", "=", "eval", "(", "self", ".", "current", ".", "lane_relations", ",", "context", ")", "except", ":", "log", ".", "exception", "(", "\"CONDITION EVAL ERROR : %s || %s\"", "%", "(", "self", ".", "current", ".", "lane_relations", ",", "context", ")", ")", "raise", "if", "not", "cond_result", ":", "log", ".", "debug", "(", "\"LANE RELATION ERR: %s %s\"", "%", "(", "self", ".", "current", ".", "lane_relations", ",", "context", ")", ")", "raise", "HTTPError", "(", "403", ",", "\"You aren't qualified for this lane: %s\"", "%", "self", ".", "current", ".", "lane_relations", ")" ]

[ "One", "or", "more", "permissions", "can", "be", "associated", "with", "a", "lane", "of", "a", "workflow", ".", "In", "a", "similar", "way", "a", "lane", "can", "be", "restricted", "with", "relation", "to", "other", "lanes", "of", "the", "workflow", "." ]

[ "def", "_gauss_filter", "(", "data", ",", "sigma", "=", "4", ",", "res_g", "=", "None", ",", "sub_blocks", "=", "(", "1", ",", "1", ",", "1", ")", ")", ":", "truncate", "=", "4.", "radius", "=", "tuple", "(", "int", "(", "truncate", "*", "s", "+", "0.5", ")", "for", "s", "in", "sigma", ")", "size", "=", "tuple", "(", "2", "*", "r", "+", "1", "for", "r", "in", "radius", ")", "s", "=", "sigma", "[", "0", "]", "if", "data", ".", "ndim", "==", "2", ":", "_filt", "=", "make_filter", "(", "_generic_filter_gpu_2d", "(", "FUNC", "=", "\"res+(val*native_exp((float)(-(ht-%s)*(ht-%s)/2/%s/%s)))\"", "%", "(", "size", "[", "0", "]", "//", "2", ",", "size", "[", "0", "]", "//", "2", ",", "s", ",", "s", ")", ",", "DEFAULT", "=", "\"0.f\"", ")", ")", "elif", "data", ".", "ndim", "==", "3", ":", "_filt", "=", "make_filter", "(", "_generic_filter_gpu_3d", "(", "FUNC", "=", "\"res+(val*native_exp((float)(-(ht-%s)*(ht-%s)/2/%s/%s)))\"", "%", "(", "size", "[", "0", "]", "//", "2", ",", "size", "[", "0", "]", "//", "2", ",", "s", ",", "s", ")", ",", "DEFAULT", "=", "\"0.f\"", ")", ")", "else", ":", "raise", "ValueError", "(", "\"currently only 2 or 3 dimensional data is supported\"", ")", "return", "_filt", "(", "data", "=", "data", ",", "size", "=", "size", ",", "res_g", "=", "res_g", ",", "sub_blocks", "=", "sub_blocks", ")" ]

[ "gaussian", "filter", "of", "given", "size" ]

[ "def", "write_warning", "(", "self", ",", "url_data", ")", ":", "self", ".", "write", "(", "self", ".", "part", "(", "\"warning\"", ")", "+", "self", ".", "spaces", "(", "\"warning\"", ")", ")", "warning_msgs", "=", "[", "u\"[%s] %s\"", "%", "x", "for", "x", "in", "url_data", ".", "warnings", "]", "self", ".", "writeln", "(", "self", ".", "wrap", "(", "warning_msgs", ",", "65", ")", ",", "color", "=", "self", ".", "colorwarning", ")" ]

[ "Write", "url_data", ".", "warning", "." ]

[ "def", "_createBitpattern", "(", "functioncode", ",", "value", ")", ":", "_checkFunctioncode", "(", "functioncode", ",", "[", "5", ",", "15", "]", ")", "_checkInt", "(", "value", ",", "minvalue", "=", "0", ",", "maxvalue", "=", "1", ",", "description", "=", "'inputvalue'", ")", "if", "functioncode", "==", "5", ":", "if", "value", "==", "0", ":", "return", "'\\x00\\x00'", "else", ":", "return", "'\\xff\\x00'", "elif", "functioncode", "==", "15", ":", "if", "value", "==", "0", ":", "return", "'\\x00'", "else", ":", "return", "'\\x01'" ]

[ "Create", "the", "bit", "pattern", "that", "is", "used", "for", "writing", "single", "bits", "." ]

[ "def", "scale", "(", "obj", ",", "multiplier", ",", "*", "*", "kwargs", ")", ":", "# Input validity checks", "if", "not", "isinstance", "(", "multiplier", ",", "(", "int", ",", "float", ")", ")", ":", "raise", "GeomdlException", "(", "\"The multiplier must be a float or an integer\"", ")", "# Keyword arguments", "inplace", "=", "kwargs", ".", "get", "(", "'inplace'", ",", "False", ")", "if", "not", "inplace", ":", "geom", "=", "copy", ".", "deepcopy", "(", "obj", ")", "else", ":", "geom", "=", "obj", "# Scale control points", "for", "g", "in", "geom", ":", "new_ctrlpts", "=", "[", "[", "]", "for", "_", "in", "range", "(", "g", ".", "ctrlpts_size", ")", "]", "for", "idx", ",", "pts", "in", "enumerate", "(", "g", ".", "ctrlpts", ")", ":", "new_ctrlpts", "[", "idx", "]", "=", "[", "p", "*", "float", "(", "multiplier", ")", "for", "p", "in", "pts", "]", "g", ".", "ctrlpts", "=", "new_ctrlpts", "return", "geom" ]

[ "Scales", "curves", "surfaces", "or", "volumes", "by", "the", "input", "multiplier", "." ]

[ "def", "in6_iseui64", "(", "x", ")", ":", "eui64", "=", "inet_pton", "(", "socket", ".", "AF_INET6", ",", "'::ff:fe00:0'", ")", "x", "=", "in6_and", "(", "inet_pton", "(", "socket", ".", "AF_INET6", ",", "x", ")", ",", "eui64", ")", "return", "x", "==", "eui64" ]

[ "Return", "True", "if", "provided", "address", "has", "an", "interface", "identifier", "part", "created", "in", "modified", "EUI", "-", "64", "format", "(", "meaning", "it", "matches", "*", "::", "*", ":", "*", "ff", ":", "fe", "*", ":", "*", ")", ".", "Otherwise", "False", "is", "returned", ".", "Address", "must", "be", "passed", "in", "printable", "format", "." ]

[ "def", "conditional_loss_ratio", "(", "loss_ratios", ",", "poes", ",", "probability", ")", ":", "assert", "len", "(", "loss_ratios", ")", ">=", "3", ",", "loss_ratios", "rpoes", "=", "poes", "[", ":", ":", "-", "1", "]", "if", "probability", ">", "poes", "[", "0", "]", ":", "# max poes", "return", "0.0", "elif", "probability", "<", "poes", "[", "-", "1", "]", ":", "# min PoE", "return", "loss_ratios", "[", "-", "1", "]", "if", "probability", "in", "poes", ":", "return", "max", "(", "[", "loss", "for", "i", ",", "loss", "in", "enumerate", "(", "loss_ratios", ")", "if", "probability", "==", "poes", "[", "i", "]", "]", ")", "else", ":", "interval_index", "=", "bisect", ".", "bisect_right", "(", "rpoes", ",", "probability", ")", "if", "interval_index", "==", "len", "(", "poes", ")", ":", "# poes are all nan", "return", "float", "(", "'nan'", ")", "elif", "interval_index", "==", "1", ":", "# boundary case", "x1", ",", "x2", "=", "poes", "[", "-", "2", ":", "]", "y1", ",", "y2", "=", "loss_ratios", "[", "-", "2", ":", "]", "else", ":", "x1", ",", "x2", "=", "poes", "[", "-", "interval_index", "-", "1", ":", "-", "interval_index", "+", "1", "]", "y1", ",", "y2", "=", "loss_ratios", "[", "-", "interval_index", "-", "1", ":", "-", "interval_index", "+", "1", "]", "return", "(", "y2", "-", "y1", ")", "/", "(", "x2", "-", "x1", ")", "*", "(", "probability", "-", "x1", ")", "+", "y1" ]

[ "Return", "the", "loss", "ratio", "corresponding", "to", "the", "given", "PoE", "(", "Probability", "of", "Exceendance", ")", ".", "We", "can", "have", "four", "cases", ":" ]

[ "def", "export_process_element", "(", "definitions", ",", "process_id", ",", "process_attributes_dictionary", ")", ":", "process", "=", "eTree", ".", "SubElement", "(", "definitions", ",", "consts", ".", "Consts", ".", "process", ")", "process", ".", "set", "(", "consts", ".", "Consts", ".", "id", ",", "process_id", ")", "process", ".", "set", "(", "consts", ".", "Consts", ".", "is_closed", ",", "process_attributes_dictionary", "[", "consts", ".", "Consts", ".", "is_closed", "]", ")", "process", ".", "set", "(", "consts", ".", "Consts", ".", "is_executable", ",", "process_attributes_dictionary", "[", "consts", ".", "Consts", ".", "is_executable", "]", ")", "process", ".", "set", "(", "consts", ".", "Consts", ".", "process_type", ",", "process_attributes_dictionary", "[", "consts", ".", "Consts", ".", "process_type", "]", ")", "return", "process" ]

[ "Creates", "process", "element", "for", "exported", "BPMN", "XML", "file", "." ]

[ "def", "default", "(", "self", ")", ":", "prop_def", "=", "getattr", "(", "self", ",", "'_default'", ",", "utils", ".", "undefined", ")", "for", "prop", "in", "self", ".", "props", ":", "if", "prop", ".", "default", "is", "utils", ".", "undefined", ":", "continue", "if", "prop_def", "is", "utils", ".", "undefined", ":", "prop_def", "=", "prop", ".", "default", "break", "return", "prop_def" ]

[ "Default", "value", "of", "the", "property" ]

[ "def", "_set_bit_size", "(", "self", ",", "size", ",", "step", "=", "1", ",", "auto_align", "=", "False", ")", ":", "# Field size", "bit_size", "=", "int", "(", "size", ")", "# Invalid field size", "if", "bit_size", "%", "step", "!=", "0", "or", "not", "(", "1", "<=", "bit_size", "<=", "64", ")", ":", "raise", "FieldSizeError", "(", "self", ",", "self", ".", "index", ",", "bit_size", ")", "# Field group size", "group_size", ",", "offset", "=", "divmod", "(", "bit_size", ",", "8", ")", "# Auto alignment", "if", "auto_align", ":", "if", "offset", "is", "not", "0", ":", "self", ".", "_align_to_byte_size", "=", "group_size", "+", "1", "else", ":", "self", ".", "_align_to_byte_size", "=", "group_size", "# Invalid field alignment", "elif", "group_size", ">", "self", ".", "alignment", ".", "byte_size", ":", "raise", "FieldAlignmentError", "(", "self", ",", "self", ".", "index", ",", "Alignment", "(", "group_size", ",", "self", ".", "alignment", ".", "bit_offset", ")", ")", "# Set field size", "self", ".", "_bit_size", "=", "bit_size" ]

[ "Sets", "the", "*", "size", "*", "of", "the", "Decimal", "field", "." ]

[ "def", "set_distributed_assembled_values", "(", "self", ",", "a_loc", ")", ":", "assert", "a_loc", ".", "size", "==", "self", ".", "_refs", "[", "'irn_loc'", "]", ".", "size", "self", ".", "_refs", ".", "update", "(", "a_loc", "=", "a_loc", ")", "self", ".", "id", ".", "a_loc", "=", "self", ".", "cast_array", "(", "a_loc", ")" ]

[ "Set", "the", "distributed", "assembled", "matrix", "values", "." ]

[ "def", "parse_type_system_definition", "(", "lexer", ":", "Lexer", ")", "->", "TypeSystemDefinitionNode", ":", "# Many definitions begin with a description and require a lookahead.", "keyword_token", "=", "lexer", ".", "lookahead", "(", ")", "if", "peek_description", "(", "lexer", ")", "else", "lexer", ".", "token", "func", "=", "_parse_type_system_definition_functions", ".", "get", "(", "cast", "(", "str", ",", "keyword_token", ".", "value", ")", ")", "if", "func", ":", "return", "func", "(", "lexer", ")", "raise", "unexpected", "(", "lexer", ",", "keyword_token", ")" ]

[ "TypeSystemDefinition" ]

[ "def", "pix2sky", "(", "self", ",", "pixel", ")", ":", "x", ",", "y", "=", "pixel", "# wcs and pyfits have oposite ideas of x/y", "return", "self", ".", "wcs", ".", "wcs_pix2world", "(", "[", "[", "y", ",", "x", "]", "]", ",", "1", ")", "[", "0", "]" ]

[ "Convert", "pixel", "coordinates", "into", "sky", "coordinates", "." ]

[ "def", "has_name_version", "(", "self", ",", "name", ":", "str", ",", "version", ":", "str", ")", "->", "bool", ":", "return", "self", ".", "session", ".", "query", "(", "exists", "(", ")", ".", "where", "(", "and_", "(", "Network", ".", "name", "==", "name", ",", "Network", ".", "version", "==", "version", ")", ")", ")", ".", "scalar", "(", ")" ]

[ "Check", "if", "there", "exists", "a", "network", "with", "the", "name", "/", "version", "combination", "in", "the", "database", "." ]

[ "def", "get_sensor_reading", "(", "self", ",", "sensorname", ")", ":", "self", ".", "init_sdr", "(", ")", "for", "sensor", "in", "self", ".", "_sdr", ".", "get_sensor_numbers", "(", ")", ":", "if", "self", ".", "_sdr", ".", "sensors", "[", "sensor", "]", ".", "name", "==", "sensorname", ":", "rsp", "=", "self", ".", "raw_command", "(", "command", "=", "0x2d", ",", "netfn", "=", "4", ",", "data", "=", "(", "sensor", ",", ")", ")", "if", "'error'", "in", "rsp", ":", "raise", "exc", ".", "IpmiException", "(", "rsp", "[", "'error'", "]", ",", "rsp", "[", "'code'", "]", ")", "return", "self", ".", "_sdr", ".", "sensors", "[", "sensor", "]", ".", "decode_sensor_reading", "(", "rsp", "[", "'data'", "]", ")", "self", ".", "oem_init", "(", ")", "return", "self", ".", "_oem", ".", "get_sensor_reading", "(", "sensorname", ")" ]

[ "Get", "a", "sensor", "reading", "by", "name" ]

[ "def", "_set_route", "(", "self", ",", "v", ",", "load", "=", "False", ")", ":", "if", "hasattr", "(", "v", ",", "\"_utype\"", ")", ":", "v", "=", "v", ".", "_utype", "(", "v", ")", "try", ":", "t", "=", "YANGDynClass", "(", "v", ",", "base", "=", "YANGListType", "(", "\"dest\"", ",", "route", ".", "route", ",", "yang_name", "=", "\"route\"", ",", "rest_name", "=", "\"route\"", ",", "parent", "=", "self", ",", "is_container", "=", "'list'", ",", "user_ordered", "=", "False", ",", "path_helper", "=", "self", ".", "_path_helper", ",", "yang_keys", "=", "'dest'", ",", "extensions", "=", "{", "u'tailf-common'", ":", "{", "u'info'", ":", "u'Configure ipv6 static route'", ",", "u'cli-suppress-list-no'", ":", "None", ",", "u'hidden'", ":", "u'full'", ",", "u'cli-suppress-mode'", ":", "None", ",", "u'cli-full-no'", ":", "None", "}", "}", ")", ",", "is_container", "=", "'list'", ",", "yang_name", "=", "\"route\"", ",", "rest_name", "=", "\"route\"", ",", "parent", "=", "self", ",", "path_helper", "=", "self", ".", "_path_helper", ",", "extmethods", "=", "self", ".", "_extmethods", ",", "register_paths", "=", "True", ",", "extensions", "=", "{", "u'tailf-common'", ":", "{", "u'info'", ":", "u'Configure ipv6 static route'", ",", "u'cli-suppress-list-no'", ":", "None", ",", "u'hidden'", ":", "u'full'", ",", "u'cli-suppress-mode'", ":", "None", ",", "u'cli-full-no'", ":", "None", "}", "}", ",", "namespace", "=", "'urn:brocade.com:mgmt:brocade-ip-forward'", ",", "defining_module", "=", "'brocade-ip-forward'", ",", "yang_type", "=", "'list'", ",", "is_config", "=", "True", ")", "except", "(", "TypeError", ",", "ValueError", ")", ":", "raise", "ValueError", "(", "{", "'error-string'", ":", "\"\"\"route must be of a type compatible with list\"\"\"", ",", "'defined-type'", ":", "\"list\"", ",", "'generated-type'", ":", "\"\"\"YANGDynClass(base=YANGListType(\"dest\",route.route, yang_name=\"route\", rest_name=\"route\", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='dest', extensions={u'tailf-common': {u'info': u'Configure ipv6 static route', u'cli-suppress-list-no': None, u'hidden': u'full', u'cli-suppress-mode': None, u'cli-full-no': None}}), is_container='list', yang_name=\"route\", rest_name=\"route\", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'tailf-common': {u'info': u'Configure ipv6 static route', u'cli-suppress-list-no': None, u'hidden': u'full', u'cli-suppress-mode': None, u'cli-full-no': None}}, namespace='urn:brocade.com:mgmt:brocade-ip-forward', defining_module='brocade-ip-forward', yang_type='list', is_config=True)\"\"\"", ",", "}", ")", "self", ".", "__route", "=", "t", "if", "hasattr", "(", "self", ",", "'_set'", ")", ":", "self", ".", "_set", "(", ")" ]

[ "Setter", "method", "for", "route", "mapped", "from", "YANG", "variable", "/", "rbridge_id", "/", "ipv6", "/", "ipv6route", "/", "route", "(", "list", ")", "If", "this", "variable", "is", "read", "-", "only", "(", "config", ":", "false", ")", "in", "the", "source", "YANG", "file", "then", "_set_route", "is", "considered", "as", "a", "private", "method", ".", "Backends", "looking", "to", "populate", "this", "variable", "should", "do", "so", "via", "calling", "thisObj", ".", "_set_route", "()", "directly", "." ]

[ "def", "propose_unif", "(", "self", ")", ":", "# Initialize a K-D Tree to assist nearest neighbor searches.", "if", "self", ".", "use_kdtree", ":", "kdtree", "=", "spatial", ".", "KDTree", "(", "self", ".", "live_u", ")", "else", ":", "kdtree", "=", "None", "while", "True", ":", "# Sample a point `u` from the union of N-spheres along with the", "# number of overlapping spheres `q` at point `u`.", "u", ",", "q", "=", "self", ".", "radfriends", ".", "sample", "(", "self", ".", "live_u", ",", "rstate", "=", "self", ".", "rstate", ",", "return_q", "=", "True", ",", "kdtree", "=", "kdtree", ")", "# Check if our sample is within the unit cube.", "if", "unitcheck", "(", "u", ",", "self", ".", "nonperiodic", ")", ":", "# Accept the point with probability 1/q to account for", "# overlapping balls.", "if", "q", "==", "1", "or", "self", ".", "rstate", ".", "rand", "(", ")", "<", "1.0", "/", "q", ":", "break", "# if successful, we're done!", "# Define the axes of the N-sphere.", "ax", "=", "np", ".", "identity", "(", "self", ".", "npdim", ")", "*", "self", ".", "radfriends", ".", "radius", "return", "u", ",", "ax" ]

[ "Propose", "a", "new", "live", "point", "by", "sampling", "*", "uniformly", "*", "within", "the", "union", "of", "N", "-", "spheres", "defined", "by", "our", "live", "points", "." ]

[ "def", "get_template", "(", "self", ",", "template_name", ")", ":", "try", ":", "return", "self", ".", "template_class", "(", "self", ".", "engine", ".", "get_template", "(", "template_name", ")", ")", "except", "mako_exceptions", ".", "TemplateLookupException", "as", "exc", ":", "raise", "TemplateDoesNotExist", "(", "exc", ".", "args", ")", "except", "mako_exceptions", ".", "CompileException", "as", "exc", ":", "raise", "TemplateSyntaxError", "(", "exc", ".", "args", ")" ]

[ "Trying", "to", "get", "a", "compiled", "template", "given", "a", "template", "name", ":", "param", "template_name", ":", "The", "template", "name", ".", ":", "raises", ":", "-", "TemplateDoesNotExist", "if", "no", "such", "template", "exists", ".", "-", "TemplateSyntaxError", "if", "we", "couldn", "t", "compile", "the", "template", "using", "Mako", "syntax", ".", ":", "return", ":", "Compiled", "Template", "." ]

[ "def", "container_list", "(", "list_names", "=", "False", ",", "remote_addr", "=", "None", ",", "cert", "=", "None", ",", "key", "=", "None", ",", "verify_cert", "=", "True", ")", ":", "client", "=", "pylxd_client_get", "(", "remote_addr", ",", "cert", ",", "key", ",", "verify_cert", ")", "containers", "=", "client", ".", "containers", ".", "all", "(", ")", "if", "list_names", ":", "return", "[", "c", ".", "name", "for", "c", "in", "containers", "]", "return", "map", "(", "_pylxd_model_to_dict", ",", "containers", ")" ]

[ "Lists", "containers" ]

[ "def", "close", "(", "self", ")", ":", "with", "self", ".", "lock", ":", "if", "self", ".", "closed", ":", "return", "self", ".", "waitqueue", ".", "put", "(", "StopIteration", ")", "self", ".", "closed", "=", "True" ]

[ "Signal", "that", "the", "executor", "will", "no", "longer", "accept", "job", "submission", ".", "Worker", "threads", "/", "processes", "are", "now", "allowed", "to", "terminate", "after", "all", "jobs", "have", "been", "are", "completed", ".", "Without", "a", "call", "to", "close", "()", "they", "will", "stay", "around", "forever", "waiting", "for", "more", "jobs", "to", "come", "." ]

[ "def", "add_note", "(", "note", ",", "*", "*", "kwargs", ")", ":", "note_i", "=", "Note", "(", ")", "note_i", ".", "ref_key", "=", "note", ".", "ref_key", "note_i", ".", "set_ref", "(", "note", ".", "ref_key", ",", "note", ".", "ref_id", ")", "note_i", ".", "value", "=", "note", ".", "value", "note_i", ".", "created_by", "=", "kwargs", ".", "get", "(", "'user_id'", ")", "db", ".", "DBSession", ".", "add", "(", "note_i", ")", "db", ".", "DBSession", ".", "flush", "(", ")", "return", "note_i" ]

[ "Add", "a", "new", "note" ]

[ "def", "text", "(", "name", ",", "data", ",", "step", "=", "None", ",", "description", "=", "None", ")", ":", "summary_metadata", "=", "metadata", ".", "create_summary_metadata", "(", "display_name", "=", "None", ",", "description", "=", "description", ")", "# TODO(https://github.com/tensorflow/tensorboard/issues/2109): remove fallback", "summary_scope", "=", "(", "getattr", "(", "tf", ".", "summary", ".", "experimental", ",", "'summary_scope'", ",", "None", ")", "or", "tf", ".", "summary", ".", "summary_scope", ")", "with", "summary_scope", "(", "name", ",", "'text_summary'", ",", "values", "=", "[", "data", ",", "step", "]", ")", "as", "(", "tag", ",", "_", ")", ":", "tf", ".", "debugging", ".", "assert_type", "(", "data", ",", "tf", ".", "string", ")", "return", "tf", ".", "summary", ".", "write", "(", "tag", "=", "tag", ",", "tensor", "=", "data", ",", "step", "=", "step", ",", "metadata", "=", "summary_metadata", ")" ]

[ "Write", "a", "text", "summary", "." ]

[ "def", "get_default_attrs", "(", "self", ")", ":", "attrs", "=", "super", "(", "BatchAction", ",", "self", ")", ".", "get_default_attrs", "(", ")", "attrs", ".", "update", "(", "{", "'data-batch-action'", ":", "'true'", "}", ")", "return", "attrs" ]

[ "Returns", "a", "list", "of", "the", "default", "HTML", "attributes", "for", "the", "action", "." ]

[ "def", "validate_metadata", "(", "self", ",", "handler", ")", ":", "if", "self", ".", "meta", "==", "'category'", ":", "new_metadata", "=", "self", ".", "metadata", "cur_metadata", "=", "handler", ".", "read_metadata", "(", "self", ".", "cname", ")", "if", "(", "new_metadata", "is", "not", "None", "and", "cur_metadata", "is", "not", "None", "and", "not", "array_equivalent", "(", "new_metadata", ",", "cur_metadata", ")", ")", ":", "raise", "ValueError", "(", "\"cannot append a categorical with \"", "\"different categories to the existing\"", ")" ]

[ "validate", "that", "kind", "=", "category", "does", "not", "change", "the", "categories" ]

[ "def", "ReadClientStartupInfoHistory", "(", "self", ",", "client_id", ",", "timerange", "=", "None", ",", "cursor", "=", "None", ")", ":", "client_id_int", "=", "db_utils", ".", "ClientIDToInt", "(", "client_id", ")", "query", "=", "(", "\"SELECT startup_info, UNIX_TIMESTAMP(timestamp) \"", "\"FROM client_startup_history \"", "\"WHERE client_id=%s \"", ")", "args", "=", "[", "client_id_int", "]", "if", "timerange", ":", "time_from", ",", "time_to", "=", "timerange", "# pylint: disable=unpacking-non-sequence", "if", "time_from", "is", "not", "None", ":", "query", "+=", "\"AND timestamp >= FROM_UNIXTIME(%s) \"", "args", ".", "append", "(", "mysql_utils", ".", "RDFDatetimeToTimestamp", "(", "time_from", ")", ")", "if", "time_to", "is", "not", "None", ":", "query", "+=", "\"AND timestamp <= FROM_UNIXTIME(%s) \"", "args", ".", "append", "(", "mysql_utils", ".", "RDFDatetimeToTimestamp", "(", "time_to", ")", ")", "query", "+=", "\"ORDER BY timestamp DESC \"", "ret", "=", "[", "]", "cursor", ".", "execute", "(", "query", ",", "args", ")", "for", "startup_info", ",", "timestamp", "in", "cursor", ".", "fetchall", "(", ")", ":", "si", "=", "rdf_client", ".", "StartupInfo", ".", "FromSerializedString", "(", "startup_info", ")", "si", ".", "timestamp", "=", "mysql_utils", ".", "TimestampToRDFDatetime", "(", "timestamp", ")", "ret", ".", "append", "(", "si", ")", "return", "ret" ]

[ "Reads", "the", "full", "startup", "history", "for", "a", "particular", "client", "." ]

[ "def", "locale_negotiator", "(", "request", ")", ":", "locale", "=", "'en'", "if", "request", ".", "accept_language", ":", "locale", "=", "request", ".", "accept_language", ".", "best_match", "(", "LANGUAGES", ")", "locale", "=", "LANGUAGES", ".", "get", "(", "locale", ",", "'en'", ")", "return", "locale" ]

[ "Locale", "negotiator", "base", "on", "the", "Accept", "-", "Language", "header" ]

[ "def", "_split_str", "(", "s", ",", "n", ")", ":", "length", "=", "len", "(", "s", ")", "return", "[", "s", "[", "i", ":", "i", "+", "n", "]", "for", "i", "in", "range", "(", "0", ",", "length", ",", "n", ")", "]" ]

[ "split", "string", "into", "list", "of", "strings", "by", "specified", "number", "." ]

[ "def", "update", "(", "self", ",", "*", "*", "data", ")", ":", "data", "=", "data", ".", "items", "(", ")", "update_command_arg", "=", "\", \"", ".", "join", "(", "\"{} = ?\"", ".", "format", "(", "entry", "[", "0", "]", ")", "for", "entry", "in", "data", ")", "cmd", "=", "\"update {table} set {update_command_arg} {where_clause}\"", ".", "format", "(", "update_command_arg", "=", "update_command_arg", ",", "where_clause", "=", "self", ".", "where_clause", ",", "table", "=", "self", ".", "table_name", ")", ".", "rstrip", "(", ")", "Repo", ".", "db", ".", "execute", "(", "cmd", ",", "[", "entry", "[", "1", "]", "for", "entry", "in", "data", "]", "+", "self", ".", "where_values", ")" ]

[ "Update", "records", "in", "the", "table", "with", "+", "data", "+", ".", "Often", "combined", "with", "where", "as", "it", "acts", "on", "all", "records", "in", "the", "table", "unless", "restricted", "." ]

[ "def", "merge_corpus", "(", "self", ",", "corpus", ")", ":", "# Create a copy, so objects aren't changed in the original merging corpus", "merging_corpus", "=", "Corpus", ".", "from_corpus", "(", "corpus", ")", "self", ".", "import_tracks", "(", "corpus", ".", "tracks", ".", "values", "(", ")", ")", "self", ".", "import_issuers", "(", "corpus", ".", "issuers", ".", "values", "(", ")", ")", "utterance_idx_mapping", "=", "self", ".", "import_utterances", "(", "corpus", ".", "utterances", ".", "values", "(", ")", ")", "for", "subview_idx", ",", "subview", "in", "merging_corpus", ".", "subviews", ".", "items", "(", ")", ":", "for", "filter", "in", "subview", ".", "filter_criteria", ":", "if", "isinstance", "(", "filter", ",", "subset", ".", "MatchingUtteranceIdxFilter", ")", ":", "new_filtered_utt_ids", "=", "set", "(", ")", "for", "utt_idx", "in", "filter", ".", "utterance_idxs", ":", "new_filtered_utt_ids", ".", "add", "(", "utterance_idx_mapping", "[", "utt_idx", "]", ".", "idx", ")", "filter", ".", "utterance_idxs", "=", "new_filtered_utt_ids", "new_idx", "=", "naming", ".", "index_name_if_in_list", "(", "subview_idx", ",", "self", ".", "subviews", ".", "keys", "(", ")", ")", "self", ".", "import_subview", "(", "new_idx", ",", "subview", ")", "for", "feat_container_idx", ",", "feat_container", "in", "merging_corpus", ".", "feature_containers", ".", "items", "(", ")", ":", "self", ".", "new_feature_container", "(", "feat_container_idx", ",", "feat_container", ".", "path", ")" ]

[ "Merge", "the", "given", "corpus", "into", "this", "corpus", ".", "All", "assets", "(", "tracks", "utterances", "issuers", "...", ")", "are", "copied", "into", "this", "corpus", ".", "If", "any", "ids", "(", "utt", "-", "idx", "track", "-", "idx", "issuer", "-", "idx", "subview", "-", "idx", "...", ")", "are", "occurring", "in", "both", "corpora", "the", "ids", "from", "the", "merging", "corpus", "are", "suffixed", "by", "a", "number", "(", "starting", "from", "1", "until", "no", "other", "is", "matching", ")", "." ]

[ "def", "_make_w3c_caps", "(", "caps", ")", ":", "caps", "=", "copy", ".", "deepcopy", "(", "caps", ")", "profile", "=", "caps", ".", "get", "(", "'firefox_profile'", ")", "always_match", "=", "{", "}", "if", "caps", ".", "get", "(", "'proxy'", ")", "and", "caps", "[", "'proxy'", "]", ".", "get", "(", "'proxyType'", ")", ":", "caps", "[", "'proxy'", "]", "[", "'proxyType'", "]", "=", "caps", "[", "'proxy'", "]", "[", "'proxyType'", "]", ".", "lower", "(", ")", "for", "k", ",", "v", "in", "caps", ".", "items", "(", ")", ":", "if", "v", "and", "k", "in", "_OSS_W3C_CONVERSION", ":", "always_match", "[", "_OSS_W3C_CONVERSION", "[", "k", "]", "]", "=", "v", ".", "lower", "(", ")", "if", "k", "==", "'platform'", "else", "v", "if", "k", "in", "_W3C_CAPABILITY_NAMES", "or", "':'", "in", "k", ":", "always_match", "[", "k", "]", "=", "v", "if", "profile", ":", "moz_opts", "=", "always_match", ".", "get", "(", "'moz:firefoxOptions'", ",", "{", "}", ")", "# If it's already present, assume the caller did that intentionally.", "if", "'profile'", "not", "in", "moz_opts", ":", "# Don't mutate the original capabilities.", "new_opts", "=", "copy", ".", "deepcopy", "(", "moz_opts", ")", "new_opts", "[", "'profile'", "]", "=", "profile", "always_match", "[", "'moz:firefoxOptions'", "]", "=", "new_opts", "return", "{", "\"firstMatch\"", ":", "[", "{", "}", "]", ",", "\"alwaysMatch\"", ":", "always_match", "}" ]

[ "Makes", "a", "W3C", "alwaysMatch", "capabilities", "object", "." ]

[ "def", "readFromProto", "(", "cls", ",", "proto", ")", ":", "instance", "=", "cls", "(", "proto", ".", "columnCount", ",", "proto", ".", "inputWidth", ")", "instance", ".", "spatialImp", "=", "proto", ".", "spatialImp", "instance", ".", "learningMode", "=", "proto", ".", "learningMode", "instance", ".", "inferenceMode", "=", "proto", ".", "inferenceMode", "instance", ".", "anomalyMode", "=", "proto", ".", "anomalyMode", "instance", ".", "topDownMode", "=", "proto", ".", "topDownMode", "spatialImp", "=", "proto", ".", "spatialImp", "instance", ".", "_sfdr", "=", "getSPClass", "(", "spatialImp", ")", ".", "read", "(", "proto", ".", "spatialPooler", ")", "return", "instance" ]

[ "Overrides", ":", "meth", ":", "~nupic", ".", "bindings", ".", "regions", ".", "PyRegion", ".", "PyRegion", ".", "readFromProto", "." ]

[ "def", "set_cached_output", "(", "self", ",", "placeholder_name", ",", "instance", ",", "output", ")", ":", "cachekey", "=", "self", ".", "get_output_cache_key", "(", "placeholder_name", ",", "instance", ")", "if", "self", ".", "cache_timeout", "is", "not", "DEFAULT_TIMEOUT", ":", "cache", ".", "set", "(", "cachekey", ",", "output", ",", "self", ".", "cache_timeout", ")", "else", ":", "# Don't want to mix into the default 0/None issue.", "cache", ".", "set", "(", "cachekey", ",", "output", ")" ]

[ "..", "versionadded", "::", "0", ".", "9", "Store", "the", "cached", "output", "for", "a", "rendered", "item", "." ]

[ "def", "__exchange_URL_in_13020loc", "(", "self", ",", "oldurl", ",", "newurl", ",", "list_of_entries", ",", "handle", ")", ":", "# Find existing 10320/LOC entries", "python_indices", "=", "self", ".", "__get_python_indices_for_key", "(", "'10320/LOC'", ",", "list_of_entries", ")", "num_exchanged", "=", "0", "if", "len", "(", "python_indices", ")", ">", "0", ":", "if", "len", "(", "python_indices", ")", ">", "1", ":", "msg", "=", "str", "(", "len", "(", "python_indices", ")", ")", "+", "' entries of type \"10320/LOC\".'", "raise", "BrokenHandleRecordException", "(", "handle", "=", "handle", ",", "msg", "=", "msg", ")", "for", "index", "in", "python_indices", ":", "entry", "=", "list_of_entries", ".", "pop", "(", "index", ")", "xmlroot", "=", "ET", ".", "fromstring", "(", "entry", "[", "'data'", "]", "[", "'value'", "]", ")", "all_URL_elements", "=", "xmlroot", ".", "findall", "(", "'location'", ")", "for", "element", "in", "all_URL_elements", ":", "if", "element", ".", "get", "(", "'href'", ")", "==", "oldurl", ":", "LOGGER", ".", "debug", "(", "'__exchange_URL_in_13020loc: Exchanging URL '", "+", "oldurl", "+", "' from 10320/LOC.'", ")", "num_exchanged", "+=", "1", "element", ".", "set", "(", "'href'", ",", "newurl", ")", "entry", "[", "'data'", "]", "[", "'value'", "]", "=", "ET", ".", "tostring", "(", "xmlroot", ",", "encoding", "=", "encoding_value", ")", "list_of_entries", ".", "append", "(", "entry", ")", "if", "num_exchanged", "==", "0", ":", "LOGGER", ".", "debug", "(", "'__exchange_URL_in_13020loc: No URLs exchanged.'", ")", "else", ":", "message", "=", "'__exchange_URL_in_13020loc: The URL \"'", "+", "oldurl", "+", "'\" was exchanged '", "+", "str", "(", "num_exchanged", ")", "+", "' times against the new url \"'", "+", "newurl", "+", "'\" in 10320/LOC.'", "message", "=", "message", ".", "replace", "(", "'1 times'", ",", "'once'", ")", "LOGGER", ".", "debug", "(", "message", ")" ]

[ "Exchange", "every", "occurrence", "of", "oldurl", "against", "newurl", "in", "a", "10320", "/", "LOC", "entry", ".", "This", "does", "not", "change", "the", "ids", "or", "other", "xml", "attributes", "of", "the", "<location", ">", "element", "." ]

[ "def", "com_google_fonts_check_varfont_generate_static", "(", "ttFont", ")", ":", "import", "tempfile", "from", "fontTools", ".", "varLib", "import", "mutator", "try", ":", "loc", "=", "{", "k", ".", "axisTag", ":", "float", "(", "(", "k", ".", "maxValue", "+", "k", ".", "minValue", ")", "/", "2", ")", "for", "k", "in", "ttFont", "[", "'fvar'", "]", ".", "axes", "}", "with", "tempfile", ".", "TemporaryFile", "(", ")", "as", "instance", ":", "font", "=", "mutator", ".", "instantiateVariableFont", "(", "ttFont", ",", "loc", ")", "font", ".", "save", "(", "instance", ")", "yield", "PASS", ",", "(", "\"fontTools.varLib.mutator generated a static font \"", "\"instance\"", ")", "except", "Exception", "as", "e", ":", "yield", "FAIL", ",", "(", "\"fontTools.varLib.mutator failed to generated a static font \"", "\"instance\\n{}\"", ".", "format", "(", "repr", "(", "e", ")", ")", ")" ]

[ "Check", "a", "static", "ttf", "can", "be", "generated", "from", "a", "variable", "font", "." ]

[ "def", "get_location", "(", "self", ")", ":", "origin", "=", "self", ".", "_frame", ".", "canvas", ".", "origin", "return", "(", "self", ".", "_x", "+", "origin", "[", "0", "]", "+", "self", ".", "_offset", ",", "self", ".", "_y", "+", "origin", "[", "1", "]", "-", "self", ".", "_frame", ".", "canvas", ".", "start_line", ")" ]

[ "Return", "the", "absolute", "location", "of", "this", "widget", "on", "the", "Screen", "taking", "into", "account", "the", "current", "state", "of", "the", "Frame", "that", "is", "displaying", "it", "and", "any", "label", "offsets", "of", "the", "Widget", "." ]

[ "def", "_listify", "(", "x", ")", ":", "if", "isinstance", "(", "x", ",", "string_types", ")", ":", "return", "[", "x", "]", "elif", "isinstance", "(", "x", ",", "collections", ".", "Iterable", ")", ":", "return", "x", "else", ":", "return", "[", "x", "]" ]

[ "Ensure", "x", "is", "iterable", ";", "if", "not", "then", "enclose", "it", "in", "a", "list", "and", "return", "it", "." ]

[ "def", "get_num_shards", "(", "num_samples", ":", "int", ",", "samples_per_shard", ":", "int", ",", "min_num_shards", ":", "int", ")", "->", "int", ":", "return", "max", "(", "int", "(", "math", ".", "ceil", "(", "num_samples", "/", "samples_per_shard", ")", ")", ",", "min_num_shards", ")" ]

[ "Returns", "the", "number", "of", "shards", "." ]

[ "def", "_parse_comment_trail", "(", "self", ")", ":", "# type: () -> Tuple[str, str, str]", "if", "self", ".", "end", "(", ")", ":", "return", "\"\"", ",", "\"\"", ",", "\"\"", "comment", "=", "\"\"", "comment_ws", "=", "\"\"", "self", ".", "mark", "(", ")", "while", "True", ":", "c", "=", "self", ".", "_current", "if", "c", "==", "\"\\n\"", ":", "break", "elif", "c", "==", "\"#\"", ":", "comment_ws", "=", "self", ".", "extract", "(", ")", "self", ".", "mark", "(", ")", "self", ".", "inc", "(", ")", "# Skip #", "# The comment itself", "while", "not", "self", ".", "end", "(", ")", "and", "not", "self", ".", "_current", ".", "is_nl", "(", ")", "and", "self", ".", "inc", "(", ")", ":", "pass", "comment", "=", "self", ".", "extract", "(", ")", "self", ".", "mark", "(", ")", "break", "elif", "c", "in", "\" \\t\\r\"", ":", "self", ".", "inc", "(", ")", "else", ":", "raise", "self", ".", "parse_error", "(", "UnexpectedCharError", ",", "c", ")", "if", "self", ".", "end", "(", ")", ":", "break", "while", "self", ".", "_current", ".", "is_spaces", "(", ")", "and", "self", ".", "inc", "(", ")", ":", "pass", "if", "self", ".", "_current", "==", "\"\\r\"", ":", "self", ".", "inc", "(", ")", "if", "self", ".", "_current", "==", "\"\\n\"", ":", "self", ".", "inc", "(", ")", "trail", "=", "\"\"", "if", "self", ".", "_idx", "!=", "self", ".", "_marker", "or", "self", ".", "_current", ".", "is_ws", "(", ")", ":", "trail", "=", "self", ".", "extract", "(", ")", "return", "comment_ws", ",", "comment", ",", "trail" ]

[ "Returns", "(", "comment_ws", "comment", "trail", ")", "If", "there", "is", "no", "comment", "comment_ws", "and", "comment", "will", "simply", "be", "empty", "." ]

[ "def", "create_surrogate_run_config", "(", "hp", ")", ":", "save_ckpt_steps", "=", "max", "(", "FLAGS", ".", "iterations_per_loop", ",", "FLAGS", ".", "local_eval_frequency", ")", "save_ckpt_secs", "=", "FLAGS", ".", "save_checkpoints_secs", "or", "None", "if", "save_ckpt_secs", ":", "save_ckpt_steps", "=", "None", "assert", "FLAGS", ".", "surrogate_output_dir", "# the various custom getters we have written do not play well together yet.", "# TODO(noam): ask rsepassi for help here.", "daisy_chain_variables", "=", "(", "hp", ".", "daisy_chain_variables", "and", "hp", ".", "activation_dtype", "==", "\"float32\"", "and", "hp", ".", "weight_dtype", "==", "\"float32\"", ")", "return", "trainer_lib", ".", "create_run_config", "(", "model_name", "=", "FLAGS", ".", "model", ",", "model_dir", "=", "os", ".", "path", ".", "expanduser", "(", "FLAGS", ".", "surrogate_output_dir", ")", ",", "master", "=", "FLAGS", ".", "master", ",", "iterations_per_loop", "=", "FLAGS", ".", "iterations_per_loop", ",", "num_shards", "=", "FLAGS", ".", "tpu_num_shards", ",", "log_device_placement", "=", "FLAGS", ".", "log_device_placement", ",", "save_checkpoints_steps", "=", "save_ckpt_steps", ",", "save_checkpoints_secs", "=", "save_ckpt_secs", ",", "keep_checkpoint_max", "=", "FLAGS", ".", "keep_checkpoint_max", ",", "keep_checkpoint_every_n_hours", "=", "FLAGS", ".", "keep_checkpoint_every_n_hours", ",", "num_gpus", "=", "FLAGS", ".", "worker_gpu", ",", "gpu_order", "=", "FLAGS", ".", "gpu_order", ",", "num_async_replicas", "=", "FLAGS", ".", "worker_replicas", ",", "gpu_mem_fraction", "=", "FLAGS", ".", "worker_gpu_memory_fraction", ",", "enable_graph_rewriter", "=", "FLAGS", ".", "enable_graph_rewriter", ",", "use_tpu", "=", "FLAGS", ".", "use_tpu", ",", "schedule", "=", "FLAGS", ".", "schedule", ",", "no_data_parallelism", "=", "hp", ".", "no_data_parallelism", ",", "daisy_chain_variables", "=", "daisy_chain_variables", ",", "ps_replicas", "=", "FLAGS", ".", "ps_replicas", ",", "ps_job", "=", "FLAGS", ".", "ps_job", ",", "ps_gpu", "=", "FLAGS", ".", "ps_gpu", ",", "sync", "=", "FLAGS", ".", "sync", ",", "worker_id", "=", "FLAGS", ".", "worker_id", ",", "worker_job", "=", "FLAGS", ".", "worker_job", ",", "random_seed", "=", "FLAGS", ".", "random_seed", ",", "tpu_infeed_sleep_secs", "=", "FLAGS", ".", "tpu_infeed_sleep_secs", ",", "inter_op_parallelism_threads", "=", "FLAGS", ".", "inter_op_parallelism_threads", ",", "log_step_count_steps", "=", "FLAGS", ".", "log_step_count_steps", ",", "intra_op_parallelism_threads", "=", "FLAGS", ".", "intra_op_parallelism_threads", ")" ]

[ "Create", "a", "run", "config", "." ]

[ "def", "setMaximumPixmapSize", "(", "self", ",", "size", ")", ":", "self", ".", "_maximumPixmapSize", "=", "size", "position", "=", "self", ".", "position", "(", ")", "self", ".", "_position", "=", "None", "self", ".", "setPosition", "(", "position", ")" ]

[ "Sets", "the", "maximum", "pixmap", "size", "for", "this", "toolbar", ".", ":", "param", "size", "|", "<int", ">" ]

[ "def", "write_sampler_metadata", "(", "self", ",", "sampler", ")", ":", "super", "(", "MultiTemperedMetadataIO", ",", "self", ")", ".", "write_sampler_metadata", "(", "sampler", ")", "self", "[", "self", ".", "sampler_group", "]", ".", "attrs", "[", "\"ntemps\"", "]", "=", "sampler", ".", "ntemps" ]

[ "Adds", "writing", "ntemps", "to", "file", "." ]

[ "def", "DAA", "(", "cpu", ")", ":", "cpu", ".", "AF", "=", "Operators", ".", "OR", "(", "(", "cpu", ".", "AL", "&", "0x0f", ")", ">", "9", ",", "cpu", ".", "AF", ")", "oldAL", "=", "cpu", ".", "AL", "cpu", ".", "AL", "=", "Operators", ".", "ITEBV", "(", "8", ",", "cpu", ".", "AF", ",", "cpu", ".", "AL", "+", "6", ",", "cpu", ".", "AL", ")", "cpu", ".", "CF", "=", "Operators", ".", "ITE", "(", "cpu", ".", "AF", ",", "Operators", ".", "OR", "(", "cpu", ".", "CF", ",", "cpu", ".", "AL", "<", "oldAL", ")", ",", "cpu", ".", "CF", ")", "cpu", ".", "CF", "=", "Operators", ".", "OR", "(", "(", "cpu", ".", "AL", "&", "0xf0", ")", ">", "0x90", ",", "cpu", ".", "CF", ")", "cpu", ".", "AL", "=", "Operators", ".", "ITEBV", "(", "8", ",", "cpu", ".", "CF", ",", "cpu", ".", "AL", "+", "0x60", ",", "cpu", ".", "AL", ")", "\"\"\"\n #old not-symbolic aware version...\n if ((cpu.AL & 0x0f) > 9) or cpu.AF:\n oldAL = cpu.AL\n cpu.AL = cpu.AL + 6\n cpu.CF = Operators.OR(cpu.CF, cpu.AL < oldAL)\n cpu.AF = True\n else:\n cpu.AF = False\n\n if ((cpu.AL & 0xf0) > 0x90) or cpu.CF:\n cpu.AL = cpu.AL + 0x60\n cpu.CF = True\n else:\n cpu.CF = False\n \"\"\"", "cpu", ".", "ZF", "=", "cpu", ".", "AL", "==", "0", "cpu", ".", "SF", "=", "(", "cpu", ".", "AL", "&", "0x80", ")", "!=", "0", "cpu", ".", "PF", "=", "cpu", ".", "_calculate_parity_flag", "(", "cpu", ".", "AL", ")" ]

[ "Decimal", "adjusts", "AL", "after", "addition", "." ]

[ "def", "serviceStatus", "(", "self", ")", ":", "r", "=", "self", ".", "_apiClient", ".", "get", "(", "\"api/v0002/service-status\"", ")", "if", "r", ".", "status_code", "==", "200", ":", "return", "ServiceStatus", "(", "*", "*", "r", ".", "json", "(", ")", ")", "else", ":", "raise", "ApiException", "(", "r", ")" ]

[ "Retrieve", "the", "organization", "-", "specific", "status", "of", "each", "of", "the", "services", "offered", "by", "the", "IBM", "Watson", "IoT", "Platform", ".", "In", "case", "of", "failure", "it", "throws", "APIException" ]

[ "def", "_substract_hemispheres", "(", "active", ",", "reference", ",", "active_sigma", ",", "reference_sigma", ",", "voxel_spacing", ")", ":", "active_kernel", "=", "_create_structure_array", "(", "active_sigma", ",", "voxel_spacing", ")", "active_smoothed", "=", "gaussian_filter", "(", "active", ",", "sigma", "=", "active_kernel", ")", "reference_kernel", "=", "_create_structure_array", "(", "reference_sigma", ",", "voxel_spacing", ")", "reference_smoothed", "=", "gaussian_filter", "(", "reference", ",", "sigma", "=", "reference_kernel", ")", "return", "active_smoothed", "-", "reference_smoothed" ]

[ "Helper", "function", "for", "_extract_hemispheric_difference", ".", "Smoothes", "both", "images", "and", "then", "substracts", "the", "reference", "from", "the", "active", "image", "." ]

[ "def", "finish", "(", "self", ",", "chunk", "=", "None", ")", ":", "self", ".", "_log_disconnect", "(", ")", "super", "(", "BaseHandler", ",", "self", ")", ".", "finish", "(", "chunk", ")" ]

[ "Tornado", "finish", "handler" ]

[ "def", "mfcc", "(", "signal", ",", "sampling_frequency", ",", "frame_length", "=", "0.020", ",", "frame_stride", "=", "0.01", ",", "num_cepstral", "=", "13", ",", "num_filters", "=", "40", ",", "fft_length", "=", "512", ",", "low_frequency", "=", "0", ",", "high_frequency", "=", "None", ",", "dc_elimination", "=", "True", ")", ":", "feature", ",", "energy", "=", "mfe", "(", "signal", ",", "sampling_frequency", "=", "sampling_frequency", ",", "frame_length", "=", "frame_length", ",", "frame_stride", "=", "frame_stride", ",", "num_filters", "=", "num_filters", ",", "fft_length", "=", "fft_length", ",", "low_frequency", "=", "low_frequency", ",", "high_frequency", "=", "high_frequency", ")", "if", "len", "(", "feature", ")", "==", "0", ":", "return", "np", ".", "empty", "(", "(", "0", ",", "num_cepstral", ")", ")", "feature", "=", "np", ".", "log", "(", "feature", ")", "feature", "=", "dct", "(", "feature", ",", "type", "=", "2", ",", "axis", "=", "-", "1", ",", "norm", "=", "'ortho'", ")", "[", ":", ",", ":", "num_cepstral", "]", "# replace first cepstral coefficient with log of frame energy for DC", "# elimination.", "if", "dc_elimination", ":", "feature", "[", ":", ",", "0", "]", "=", "np", ".", "log", "(", "energy", ")", "return", "feature" ]

[ "Compute", "MFCC", "features", "from", "an", "audio", "signal", "." ]

[ "def", "delete_roles", "(", "apps", ",", "schema_editor", ")", ":", "SystemWideEnterpriseRole", "=", "apps", ".", "get_model", "(", "'enterprise'", ",", "'SystemWideEnterpriseRole'", ")", "SystemWideEnterpriseRole", ".", "objects", ".", "filter", "(", "name__in", "=", "[", "ENTERPRISE_OPERATOR_ROLE", "]", ")", ".", "delete", "(", ")" ]

[ "Delete", "the", "enterprise", "roles", "." ]

[ "def", "filterCollapsedItems", "(", "data", ")", ":", "return", "(", "(", "key", ",", "value", ")", "for", "key", ",", "value", "in", "six", ".", "iteritems", "(", "data", ")", "if", "not", "(", "isinstance", "(", "value", ",", "StatContainer", ")", "and", "value", ".", "isCollapsed", "(", ")", ")", ")" ]

[ "Return", "a", "filtered", "iteration", "over", "a", "list", "of", "items", "." ]

[ "def", "channels_open", "(", "self", ",", "room_id", ",", "*", "*", "kwargs", ")", ":", "return", "self", ".", "__call_api_post", "(", "'channels.open'", ",", "roomId", "=", "room_id", ",", "kwargs", "=", "kwargs", ")" ]

[ "Adds", "the", "channel", "back", "to", "the", "user’s", "list", "of", "channels", "." ]

[ "def", "encrypt_password", "(", "self", ",", "raw_password", ")", ":", "PraetorianError", ".", "require_condition", "(", "self", ".", "pwd_ctx", "is", "not", "None", ",", "\"Praetorian must be initialized before this method is available\"", ",", ")", "return", "self", ".", "pwd_ctx", ".", "encrypt", "(", "raw_password", ",", "scheme", "=", "self", ".", "hash_scheme", ")" ]

[ "Encrypts", "a", "plaintext", "password", "using", "the", "stored", "passlib", "password", "context" ]

[ "def", "_handle_events", "(", "self", ",", "fd", ":", "int", ",", "events", ":", "int", ")", "->", "None", ":", "action", "=", "0", "if", "events", "&", "ioloop", ".", "IOLoop", ".", "READ", ":", "action", "|=", "pycurl", ".", "CSELECT_IN", "if", "events", "&", "ioloop", ".", "IOLoop", ".", "WRITE", ":", "action", "|=", "pycurl", ".", "CSELECT_OUT", "while", "True", ":", "try", ":", "ret", ",", "num_handles", "=", "self", ".", "_multi", ".", "socket_action", "(", "fd", ",", "action", ")", "except", "pycurl", ".", "error", "as", "e", ":", "ret", "=", "e", ".", "args", "[", "0", "]", "if", "ret", "!=", "pycurl", ".", "E_CALL_MULTI_PERFORM", ":", "break", "self", ".", "_finish_pending_requests", "(", ")" ]

[ "Called", "by", "IOLoop", "when", "there", "is", "activity", "on", "one", "of", "our", "file", "descriptors", "." ]

[ "def", "murmur3_64", "(", "data", ":", "Union", "[", "bytes", ",", "bytearray", "]", ",", "seed", ":", "int", "=", "19820125", ")", "->", "int", ":", "# noqa", "m", "=", "0xc6a4a7935bd1e995", "r", "=", "47", "mask", "=", "2", "**", "64", "-", "1", "length", "=", "len", "(", "data", ")", "h", "=", "seed", "^", "(", "(", "m", "*", "length", ")", "&", "mask", ")", "offset", "=", "(", "length", "//", "8", ")", "*", "8", "# RNC: was /, but for Python 3 that gives float; brackets added for clarity", "for", "ll", "in", "range", "(", "0", ",", "offset", ",", "8", ")", ":", "k", "=", "bytes_to_long", "(", "data", "[", "ll", ":", "ll", "+", "8", "]", ")", "k", "=", "(", "k", "*", "m", ")", "&", "mask", "k", "^=", "(", "k", ">>", "r", ")", "&", "mask", "k", "=", "(", "k", "*", "m", ")", "&", "mask", "h", "=", "(", "h", "^", "k", ")", "h", "=", "(", "h", "*", "m", ")", "&", "mask", "l", "=", "length", "&", "7", "if", "l", ">=", "7", ":", "h", "=", "(", "h", "^", "(", "data", "[", "offset", "+", "6", "]", "<<", "48", ")", ")", "if", "l", ">=", "6", ":", "h", "=", "(", "h", "^", "(", "data", "[", "offset", "+", "5", "]", "<<", "40", ")", ")", "if", "l", ">=", "5", ":", "h", "=", "(", "h", "^", "(", "data", "[", "offset", "+", "4", "]", "<<", "32", ")", ")", "if", "l", ">=", "4", ":", "h", "=", "(", "h", "^", "(", "data", "[", "offset", "+", "3", "]", "<<", "24", ")", ")", "if", "l", ">=", "3", ":", "h", "=", "(", "h", "^", "(", "data", "[", "offset", "+", "2", "]", "<<", "16", ")", ")", "if", "l", ">=", "2", ":", "h", "=", "(", "h", "^", "(", "data", "[", "offset", "+", "1", "]", "<<", "8", ")", ")", "if", "l", ">=", "1", ":", "h", "=", "(", "h", "^", "data", "[", "offset", "]", ")", "h", "=", "(", "h", "*", "m", ")", "&", "mask", "h", "^=", "(", "h", ">>", "r", ")", "&", "mask", "h", "=", "(", "h", "*", "m", ")", "&", "mask", "h", "^=", "(", "h", ">>", "r", ")", "&", "mask", "return", "h" ]

[ "Pure", "64", "-", "bit", "Python", "implementation", "of", "MurmurHash3", ";", "see", "http", ":", "//", "stackoverflow", ".", "com", "/", "questions", "/", "13305290", "/", "is", "-", "there", "-", "a", "-", "pure", "-", "python", "-", "implementation", "-", "of", "-", "murmurhash", "(", "plus", "RNC", "bugfixes", ")", ".", "Args", ":", "data", ":", "data", "to", "hash", "seed", ":", "seed" ]

[ "def", "filter_nonspellcheckable_tokens", "(", "line", ",", "block_out_regexes", "=", "None", ")", ":", "all_block_out_regexes", "=", "[", "r\"[^\\s]*:[^\\s]*[/\\\\][^\\s]*\"", ",", "r\"[^\\s]*[/\\\\][^\\s]*\"", ",", "r\"\\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\\.[A-Za-z]+\\b\"", "]", "+", "(", "block_out_regexes", "or", "list", "(", ")", ")", "for", "block_regex", "in", "all_block_out_regexes", ":", "for", "marker", "in", "re", ".", "finditer", "(", "block_regex", ",", "line", ")", ":", "spaces", "=", "\" \"", "*", "(", "marker", ".", "end", "(", ")", "-", "marker", ".", "start", "(", ")", ")", "line", "=", "line", "[", ":", "marker", ".", "start", "(", ")", "]", "+", "spaces", "+", "line", "[", "marker", ".", "end", "(", ")", ":", "]", "return", "line" ]

[ "Return", "line", "with", "paths", "urls", "and", "emails", "filtered", "out", "." ]

[ "def", "ignore", "(", "self", ",", "argument_dest", ",", "*", "*", "kwargs", ")", ":", "self", ".", "_check_stale", "(", ")", "if", "not", "self", ".", "_applicable", "(", ")", ":", "return", "dest_option", "=", "[", "'--__{}'", ".", "format", "(", "argument_dest", ".", "upper", "(", ")", ")", "]", "self", ".", "argument", "(", "argument_dest", ",", "arg_type", "=", "ignore_type", ",", "options_list", "=", "dest_option", ",", "*", "*", "kwargs", ")" ]

[ "Register", "an", "argument", "with", "type", "knack", ".", "arguments", ".", "ignore_type", "(", "hidden", "/", "ignored", ")" ]

[ "def", "add_variables_from", "(", "self", ",", "variables", ",", "cards", ")", ":", "for", "var", ",", "card", "in", "zip", "(", "variables", ",", "cards", ")", ":", "self", ".", "add_variable", "(", "var", ",", "card", ")" ]

[ "Add", "several", "variables", "to", "the", "model", "at", "once", "." ]

[ "def", "getSharedSecretActive", "(", "self", ",", "other_public_bundle", ",", "allow_zero_otpks", "=", "False", ")", ":", "self", ".", "__checkSPKTimestamp", "(", ")", "other_ik", "=", "self", ".", "__KeyPair", "(", "pub", "=", "other_public_bundle", ".", "ik", ")", "other_spk", "=", "{", "\"key\"", ":", "self", ".", "__KeyPair", "(", "pub", "=", "other_public_bundle", ".", "spk", ")", ",", "\"signature\"", ":", "other_public_bundle", ".", "spk_signature", "}", "other_otpks", "=", "[", "self", ".", "__KeyPair", "(", "pub", "=", "otpk", ")", "for", "otpk", "in", "other_public_bundle", ".", "otpks", "]", "if", "len", "(", "other_otpks", ")", "==", "0", "and", "not", "allow_zero_otpks", ":", "raise", "KeyExchangeException", "(", "\"The other public bundle does not contain any OTPKs, which is not \"", "+", "\"allowed.\"", ")", "other_spk_serialized", "=", "self", ".", "__PublicKeyEncoder", ".", "encodePublicKey", "(", "other_spk", "[", "\"key\"", "]", ".", "pub", ",", "self", ".", "__curve", ")", "if", "not", "self", ".", "__XEdDSA", "(", "mont_pub", "=", "other_ik", ".", "pub", ")", ".", "verify", "(", "other_spk_serialized", ",", "other_spk", "[", "\"signature\"", "]", ")", ":", "raise", "KeyExchangeException", "(", "\"The signature of this public bundle's spk could not be verifified.\"", ")", "ek", "=", "self", ".", "__KeyPair", ".", "generate", "(", ")", "dh1", "=", "self", ".", "__ik", ".", "getSharedSecret", "(", "other_spk", "[", "\"key\"", "]", ")", "dh2", "=", "ek", ".", "getSharedSecret", "(", "other_ik", ")", "dh3", "=", "ek", ".", "getSharedSecret", "(", "other_spk", "[", "\"key\"", "]", ")", "dh4", "=", "b\"\"", "otpk", "=", "None", "if", "len", "(", "other_otpks", ")", ">", "0", ":", "otpk_index", "=", "ord", "(", "os", ".", "urandom", "(", "1", ")", ")", "%", "len", "(", "other_otpks", ")", "otpk", "=", "other_otpks", "[", "otpk_index", "]", "dh4", "=", "ek", ".", "getSharedSecret", "(", "otpk", ")", "sk", "=", "self", ".", "__kdf", "(", "dh1", "+", "dh2", "+", "dh3", "+", "dh4", ")", "ik_pub_serialized", "=", "self", ".", "__PublicKeyEncoder", ".", "encodePublicKey", "(", "self", ".", "__ik", ".", "pub", ",", "self", ".", "__curve", ")", "other_ik_pub_serialized", "=", "self", ".", "__PublicKeyEncoder", ".", "encodePublicKey", "(", "other_ik", ".", "pub", ",", "self", ".", "__curve", ")", "ad", "=", "ik_pub_serialized", "+", "other_ik_pub_serialized", "return", "{", "\"to_other\"", ":", "{", "\"ik\"", ":", "self", ".", "__ik", ".", "pub", ",", "\"ek\"", ":", "ek", ".", "pub", ",", "\"otpk\"", ":", "otpk", ".", "pub", "if", "otpk", "else", "None", ",", "\"spk\"", ":", "other_spk", "[", "\"key\"", "]", ".", "pub", "}", ",", "\"ad\"", ":", "ad", ",", "\"sk\"", ":", "sk", "}" ]

[ "Do", "the", "key", "exchange", "as", "the", "active", "party", ".", "This", "involves", "selecting", "keys", "from", "the", "passive", "parties", "public", "bundle", "." ]

[ "def", "_mb_normal_model", "(", "self", ",", "beta", ",", "mini_batch", ")", ":", "rand_int", "=", "np", ".", "random", ".", "randint", "(", "low", "=", "0", ",", "high", "=", "self", ".", "data_length", "-", "mini_batch", "-", "self", ".", "max_lag", "+", "1", ")", "sample", "=", "np", ".", "arange", "(", "start", "=", "rand_int", ",", "stop", "=", "rand_int", "+", "mini_batch", ")", "data", "=", "self", ".", "y", "[", "sample", "]", "X", "=", "self", ".", "X", "[", "sample", ",", ":", "]", "Y", "=", "data", "[", "self", ".", "max_lag", ":", "]", "if", "self", ".", "ar", "!=", "0", ":", "ar_matrix", "=", "data", "[", "(", "self", ".", "max_lag", "-", "1", ")", ":", "-", "1", "]", "for", "i", "in", "range", "(", "1", ",", "self", ".", "ar", ")", ":", "ar_matrix", "=", "np", ".", "vstack", "(", "(", "ar_matrix", ",", "data", "[", "(", "self", ".", "max_lag", "-", "i", "-", "1", ")", ":", "-", "i", "-", "1", "]", ")", ")", "else", ":", "ar_matrix", "=", "np", ".", "zeros", "(", "data", ".", "shape", "[", "0", "]", "-", "self", ".", "max_lag", ")", "# Transform latent variables", "z", "=", "np", ".", "array", "(", "[", "self", ".", "latent_variables", ".", "z_list", "[", "k", "]", ".", "prior", ".", "transform", "(", "beta", "[", "k", "]", ")", "for", "k", "in", "range", "(", "beta", ".", "shape", "[", "0", "]", ")", "]", ")", "# Constant and AR terms", "if", "self", ".", "ar", "==", "0", ":", "mu", "=", "np", ".", "transpose", "(", "ar_matrix", ")", "elif", "self", ".", "ar", "==", "1", ":", "mu", "=", "np", ".", "transpose", "(", "ar_matrix", ")", "*", "z", "[", ":", "-", "self", ".", "family_z_no", "-", "self", ".", "ma", "-", "len", "(", "self", ".", "X_names", ")", "]", "[", "0", "]", "else", ":", "mu", "=", "np", ".", "matmul", "(", "np", ".", "transpose", "(", "ar_matrix", ")", ",", "z", "[", ":", "-", "self", ".", "family_z_no", "-", "self", ".", "ma", "-", "len", "(", "self", ".", "X_names", ")", "]", ")", "# X terms", "mu", "=", "mu", "+", "np", ".", "matmul", "(", "X", "[", "self", ".", "integ", "+", "self", ".", "max_lag", ":", "]", ",", "z", "[", "self", ".", "ma", "+", "self", ".", "ar", ":", "(", "self", ".", "ma", "+", "self", ".", "ar", "+", "len", "(", "self", ".", "X_names", ")", ")", "]", ")", "# MA terms", "if", "self", ".", "ma", "!=", "0", ":", "mu", "=", "arimax_recursion", "(", "z", ",", "mu", ",", "Y", ",", "self", ".", "max_lag", ",", "Y", ".", "shape", "[", "0", "]", ",", "self", ".", "ar", ",", "self", ".", "ma", ")", "return", "mu", ",", "Y" ]

[ "Creates", "the", "structure", "of", "the", "model", "(", "model", "matrices", "etc", ")", "for", "a", "mini", "-", "batch", "Normal", "family", "ARIMAX", "model", "." ]

[ "def", "set", "(", "self", ",", "value", ")", ":", "self", ".", "_elk", ".", "send", "(", "cx_encode", "(", "self", ".", "_index", ",", "value", ")", ")" ]

[ "(", "Helper", ")", "Set", "counter", "to", "value" ]

[ "def", "info", "(", "self", ",", "*", "args", ")", "->", "\"Err\"", ":", "error", "=", "self", ".", "_create_err", "(", "\"info\"", ",", "*", "args", ")", "print", "(", "self", ".", "_errmsg", "(", "error", ")", ")", "return", "error" ]

[ "Creates", "an", "info", "message" ]

[ "def", "reset_to_last_commit", "(", ")", ":", "try", ":", "repo", "=", "Repo", "(", ")", "gitcmd", "=", "repo", ".", "git", "gitcmd", ".", "reset", "(", "hard", "=", "True", ")", "except", "Exception", ":", "pass" ]

[ "reset", "a", "modified", "file", "to", "his", "last", "commit", "status" ]

[ "def", "kernels_output_cli", "(", "self", ",", "kernel", ",", "kernel_opt", "=", "None", ",", "path", "=", "None", ",", "force", "=", "False", ",", "quiet", "=", "False", ")", ":", "kernel", "=", "kernel", "or", "kernel_opt", "self", ".", "kernels_output", "(", "kernel", ",", "path", ",", "force", ",", "quiet", ")" ]

[ "client", "wrapper", "for", "kernels_output", "with", "same", "arguments", ".", "Extra", "arguments", "are", "described", "below", "and", "see", "kernels_output", "for", "others", ".", "Parameters", "==========", "kernel_opt", ":", "option", "from", "client", "instead", "of", "kernel", "if", "not", "defined" ]

[ "def", "wnexpd", "(", "left", ",", "right", ",", "window", ")", ":", "assert", "isinstance", "(", "window", ",", "stypes", ".", "SpiceCell", ")", "assert", "window", ".", "dtype", "==", "1", "left", "=", "ctypes", ".", "c_double", "(", "left", ")", "right", "=", "ctypes", ".", "c_double", "(", "right", ")", "libspice", ".", "wnexpd_c", "(", "left", ",", "right", ",", "ctypes", ".", "byref", "(", "window", ")", ")", "return", "window" ]

[ "Expand", "each", "of", "the", "intervals", "of", "a", "double", "precision", "window", "." ]

[ "def", "_setup_x86_arch", "(", "self", ",", "arch_mode", "=", "None", ")", ":", "if", "arch_mode", "is", "None", ":", "arch_mode", "=", "self", ".", "binary", ".", "architecture_mode", "# Set up architecture information", "self", ".", "name", "=", "\"x86\"", "self", ".", "arch_info", "=", "X86ArchitectureInformation", "(", "arch_mode", ")", "self", ".", "disassembler", "=", "X86Disassembler", "(", "arch_mode", ")", "self", ".", "ir_translator", "=", "X86Translator", "(", "arch_mode", ")" ]

[ "Set", "up", "x86", "architecture", "." ]

[ "def", "bowtie2_alignment_plot", "(", "self", ")", ":", "half_warning", "=", "''", "for", "s_name", "in", "self", ".", "bowtie2_data", ":", "if", "'paired_aligned_mate_one_halved'", "in", "self", ".", "bowtie2_data", "[", "s_name", "]", "or", "'paired_aligned_mate_multi_halved'", "in", "self", ".", "bowtie2_data", "[", "s_name", "]", "or", "'paired_aligned_mate_none_halved'", "in", "self", ".", "bowtie2_data", "[", "s_name", "]", ":", "half_warning", "=", "'<em>Please note that single mate alignment counts are halved to tally with pair counts properly.</em>'", "description_text", "=", "'This plot shows the number of reads aligning to the reference in different ways.'", "# Config for the plot", "config", "=", "{", "'ylab'", ":", "'# Reads'", ",", "'cpswitch_counts_label'", ":", "'Number of Reads'", "}", "# Two plots, don't mix SE with PE", "if", "self", ".", "num_se", ">", "0", ":", "sekeys", "=", "OrderedDict", "(", ")", "sekeys", "[", "'unpaired_aligned_one'", "]", "=", "{", "'color'", ":", "'#20568f'", ",", "'name'", ":", "'SE mapped uniquely'", "}", "sekeys", "[", "'unpaired_aligned_multi'", "]", "=", "{", "'color'", ":", "'#f7a35c'", ",", "'name'", ":", "'SE multimapped'", "}", "sekeys", "[", "'unpaired_aligned_none'", "]", "=", "{", "'color'", ":", "'#981919'", ",", "'name'", ":", "'SE not aligned'", "}", "config", "[", "'id'", "]", "=", "'bowtie2_se_plot'", "config", "[", "'title'", "]", "=", "'Bowtie 2: SE Alignment Scores'", "self", ".", "add_section", "(", "description", "=", "description_text", ",", "helptext", "=", "'''\n There are 3 possible types of alignment:\n * **SE Mapped uniquely**: Read has only one occurence in the reference genome.\n * **SE Multimapped**: Read has multiple occurence.\n * **SE No aligned**: Read has no occurence.\n '''", ",", "plot", "=", "bargraph", ".", "plot", "(", "self", ".", "bowtie2_data", ",", "sekeys", ",", "config", ")", ")", "if", "self", ".", "num_pe", ">", "0", ":", "pekeys", "=", "OrderedDict", "(", ")", "pekeys", "[", "'paired_aligned_one'", "]", "=", "{", "'color'", ":", "'#20568f'", ",", "'name'", ":", "'PE mapped uniquely'", "}", "pekeys", "[", "'paired_aligned_discord_one'", "]", "=", "{", "'color'", ":", "'#5c94ca'", ",", "'name'", ":", "'PE mapped discordantly uniquely'", "}", "pekeys", "[", "'paired_aligned_mate_one_halved'", "]", "=", "{", "'color'", ":", "'#95ceff'", ",", "'name'", ":", "'PE one mate mapped uniquely'", "}", "pekeys", "[", "'paired_aligned_multi'", "]", "=", "{", "'color'", ":", "'#f7a35c'", ",", "'name'", ":", "'PE multimapped'", "}", "pekeys", "[", "'paired_aligned_discord_multi'", "]", "=", "{", "'color'", ":", "'#dce333'", ",", "'name'", ":", "'PE discordantly multimapped'", "}", "pekeys", "[", "'paired_aligned_mate_multi_halved'", "]", "=", "{", "'color'", ":", "'#ffeb75'", ",", "'name'", ":", "'PE one mate multimapped'", "}", "pekeys", "[", "'paired_aligned_mate_none_halved'", "]", "=", "{", "'color'", ":", "'#981919'", ",", "'name'", ":", "'PE neither mate aligned'", "}", "config", "[", "'id'", "]", "=", "'bowtie2_pe_plot'", "config", "[", "'title'", "]", "=", "'Bowtie 2: PE Alignment Scores'", "self", ".", "add_section", "(", "description", "=", "\"<br>\"", ".", "join", "(", "[", "description_text", ",", "half_warning", "]", ")", ",", "helptext", "=", "'''\n There are 6 possible types of alignment:\n * **PE mapped uniquely**: Pair has only one occurence in the reference genome.\n * **PE mapped discordantly uniquely**: Pair has only one occurence but not in proper pair.\n * **PE one mate mapped uniquely**: One read of a pair has one occurence.\n * **PE multimapped**: Pair has multiple occurence.\n * **PE one mate multimapped**: One read of a pair has multiple occurence.\n * **PE neither mate aligned**: Pair has no occurence.\n '''", ",", "plot", "=", "bargraph", ".", "plot", "(", "self", ".", "bowtie2_data", ",", "pekeys", ",", "config", ")", ")" ]

[ "Make", "the", "HighCharts", "HTML", "to", "plot", "the", "alignment", "rates" ]