Datasets:

---

kejian

/

codesearchnet-python-raw

like 1

[ "def", "_sub_resource", "(", "self", ",", "path", ")", ":", "if", "path", "not", "in", "self", ".", "resource_map", ":", "self", ".", "resource_map", "[", "path", "]", "=", "Resource", "(", "path", ",", "self", ".", "fetch", ",", "self", ".", "resource_map", ",", "default_headers", "=", "self", ".", "default_headers", ")", "return", "self", ".", "resource_map", "[", "path", "]" ]

[ "get", "or", "create", "sub", "resource" ]

[ "def", "decode_timeseries_row", "(", "self", ",", "tsrow", ",", "tscols", "=", "None", ",", "convert_timestamp", "=", "False", ")", ":", "row", "=", "[", "]", "for", "i", ",", "cell", "in", "enumerate", "(", "tsrow", ".", "cells", ")", ":", "col", "=", "None", "if", "tscols", "is", "not", "None", ":", "col", "=", "tscols", "[", "i", "]", "if", "cell", ".", "HasField", "(", "'varchar_value'", ")", ":", "if", "col", "and", "not", "(", "col", ".", "type", "==", "TsColumnType", ".", "Value", "(", "'VARCHAR'", ")", "or", "col", ".", "type", "==", "TsColumnType", ".", "Value", "(", "'BLOB'", ")", ")", ":", "raise", "TypeError", "(", "'expected VARCHAR or BLOB column'", ")", "else", ":", "row", ".", "append", "(", "cell", ".", "varchar_value", ")", "elif", "cell", ".", "HasField", "(", "'sint64_value'", ")", ":", "if", "col", "and", "col", ".", "type", "!=", "TsColumnType", ".", "Value", "(", "'SINT64'", ")", ":", "raise", "TypeError", "(", "'expected SINT64 column'", ")", "else", ":", "row", ".", "append", "(", "cell", ".", "sint64_value", ")", "elif", "cell", ".", "HasField", "(", "'double_value'", ")", ":", "if", "col", "and", "col", ".", "type", "!=", "TsColumnType", ".", "Value", "(", "'DOUBLE'", ")", ":", "raise", "TypeError", "(", "'expected DOUBLE column'", ")", "else", ":", "row", ".", "append", "(", "cell", ".", "double_value", ")", "elif", "cell", ".", "HasField", "(", "'timestamp_value'", ")", ":", "if", "col", "and", "col", ".", "type", "!=", "TsColumnType", ".", "Value", "(", "'TIMESTAMP'", ")", ":", "raise", "TypeError", "(", "'expected TIMESTAMP column'", ")", "else", ":", "dt", "=", "cell", ".", "timestamp_value", "if", "convert_timestamp", ":", "dt", "=", "datetime_from_unix_time_millis", "(", "cell", ".", "timestamp_value", ")", "row", ".", "append", "(", "dt", ")", "elif", "cell", ".", "HasField", "(", "'boolean_value'", ")", ":", "if", "col", "and", "col", ".", "type", "!=", "TsColumnType", ".", "Value", "(", "'BOOLEAN'", ")", ":", "raise", "TypeError", "(", "'expected BOOLEAN column'", ")", "else", ":", "row", ".", "append", "(", "cell", ".", "boolean_value", ")", "else", ":", "row", ".", "append", "(", "None", ")", "return", "row" ]

[ "Decodes", "a", "TsRow", "into", "a", "list" ]

[ "def", "strsettings", "(", "self", ",", "indent", "=", "0", ",", "maxindent", "=", "25", ",", "width", "=", "0", ")", ":", "out", "=", "[", "]", "makelabel", "=", "lambda", "name", ":", "' '", "*", "indent", "+", "name", "+", "': '", "settingsindent", "=", "_autoindent", "(", "[", "makelabel", "(", "s", ")", "for", "s", "in", "self", ".", "options", "]", ",", "indent", ",", "maxindent", ")", "for", "name", "in", "self", ".", "option_order", ":", "option", "=", "self", ".", "options", "[", "name", "]", "label", "=", "makelabel", "(", "name", ")", "settingshelp", "=", "\"%s(%s): %s\"", "%", "(", "option", ".", "formatname", ",", "option", ".", "strvalue", ",", "option", ".", "location", ")", "wrapped", "=", "self", ".", "_wrap_labelled", "(", "label", ",", "settingshelp", ",", "settingsindent", ",", "width", ")", "out", ".", "extend", "(", "wrapped", ")", "return", "'\\n'", ".", "join", "(", "out", ")" ]

[ "Return", "user", "friendly", "help", "on", "positional", "arguments", "." ]

[ "def", "absent", "(", "profile", "=", "'pagerduty'", ",", "subdomain", "=", "None", ",", "api_key", "=", "None", ",", "*", "*", "kwargs", ")", ":", "r", "=", "__salt__", "[", "'pagerduty_util.resource_absent'", "]", "(", "'services'", ",", "[", "'name'", ",", "'id'", "]", ",", "profile", ",", "subdomain", ",", "api_key", ",", "*", "*", "kwargs", ")", "return", "r" ]

[ "Ensure", "a", "pagerduty", "service", "does", "not", "exist", ".", "Name", "can", "be", "the", "service", "name", "or", "pagerduty", "service", "id", "." ]

[ "def", "create", "(", "self", ",", "friendly_name", "=", "values", ".", "unset", ",", "apn_credential_sid", "=", "values", ".", "unset", ",", "gcm_credential_sid", "=", "values", ".", "unset", ",", "messaging_service_sid", "=", "values", ".", "unset", ",", "facebook_messenger_page_id", "=", "values", ".", "unset", ",", "default_apn_notification_protocol_version", "=", "values", ".", "unset", ",", "default_gcm_notification_protocol_version", "=", "values", ".", "unset", ",", "fcm_credential_sid", "=", "values", ".", "unset", ",", "default_fcm_notification_protocol_version", "=", "values", ".", "unset", ",", "log_enabled", "=", "values", ".", "unset", ",", "alexa_skill_id", "=", "values", ".", "unset", ",", "default_alexa_notification_protocol_version", "=", "values", ".", "unset", ")", ":", "data", "=", "values", ".", "of", "(", "{", "'FriendlyName'", ":", "friendly_name", ",", "'ApnCredentialSid'", ":", "apn_credential_sid", ",", "'GcmCredentialSid'", ":", "gcm_credential_sid", ",", "'MessagingServiceSid'", ":", "messaging_service_sid", ",", "'FacebookMessengerPageId'", ":", "facebook_messenger_page_id", ",", "'DefaultApnNotificationProtocolVersion'", ":", "default_apn_notification_protocol_version", ",", "'DefaultGcmNotificationProtocolVersion'", ":", "default_gcm_notification_protocol_version", ",", "'FcmCredentialSid'", ":", "fcm_credential_sid", ",", "'DefaultFcmNotificationProtocolVersion'", ":", "default_fcm_notification_protocol_version", ",", "'LogEnabled'", ":", "log_enabled", ",", "'AlexaSkillId'", ":", "alexa_skill_id", ",", "'DefaultAlexaNotificationProtocolVersion'", ":", "default_alexa_notification_protocol_version", ",", "}", ")", "payload", "=", "self", ".", "_version", ".", "create", "(", "'POST'", ",", "self", ".", "_uri", ",", "data", "=", "data", ",", ")", "return", "ServiceInstance", "(", "self", ".", "_version", ",", "payload", ",", ")" ]

[ "Create", "a", "new", "ServiceInstance" ]

[ "def", "extract_value", "(", "self", ",", "string", ",", "key", ",", "inline_code", "=", "True", ")", ":", "regex", "=", "r'\\* '", "+", "key", "+", "': '", "if", "inline_code", ":", "regex", "=", "regex", "+", "'``(.*)``'", "else", ":", "regex", "=", "regex", "+", "'(.*)'", "value", "=", "re", ".", "findall", "(", "regex", ",", "string", ")", "if", "value", ":", "return", "value", "[", "0", "]", ".", "replace", "(", "'``'", ",", "''", ")", "else", ":", "return", "False" ]

[ "Extract", "strings", "from", "the", "docstrings" ]

[ "def", "getproductsurl", "(", "idproduct", ",", "*", "args", ",", "*", "*", "kwargs", ")", ":", "productidparam", "=", "\"\"", "if", "idproduct", "==", "\"\"", "else", "\"/\"", "+", "idproduct", "url", "=", "getmambuurl", "(", "*", "args", ",", "*", "*", "kwargs", ")", "+", "\"loanproducts\"", "+", "productidparam", "return", "url" ]

[ "Request", "loan", "Products", "URL", "." ]

[ "def", "_gotitem", "(", "self", ",", "key", ",", "ndim", ",", "subset", "=", "None", ")", ":", "# create a new object to prevent aliasing", "if", "subset", "is", "None", ":", "subset", "=", "self", ".", "obj", "# we need to make a shallow copy of ourselves", "# with the same groupby", "kwargs", "=", "{", "attr", ":", "getattr", "(", "self", ",", "attr", ")", "for", "attr", "in", "self", ".", "_attributes", "}", "# Try to select from a DataFrame, falling back to a Series", "try", ":", "groupby", "=", "self", ".", "_groupby", "[", "key", "]", "except", "IndexError", ":", "groupby", "=", "self", ".", "_groupby", "self", "=", "self", ".", "__class__", "(", "subset", ",", "groupby", "=", "groupby", ",", "parent", "=", "self", ",", "*", "*", "kwargs", ")", "self", ".", "_reset_cache", "(", ")", "if", "subset", ".", "ndim", "==", "2", ":", "if", "is_scalar", "(", "key", ")", "and", "key", "in", "subset", "or", "is_list_like", "(", "key", ")", ":", "self", ".", "_selection", "=", "key", "return", "self" ]

[ "Sub", "-", "classes", "to", "define", ".", "Return", "a", "sliced", "object", "." ]

[ "def", "feather_links", "(", "self", ",", "factor", "=", "0.01", ",", "include_self", "=", "False", ")", ":", "def", "feather_node", "(", "node", ")", ":", "node_weight_sum", "=", "sum", "(", "l", ".", "weight", "for", "l", "in", "node", ".", "link_list", ")", "# Iterate over a copy of the original link list since we will", "# need to refer to this while modifying node.link_list", "for", "original_link", "in", "node", ".", "link_list", "[", ":", "]", ":", "neighbor_node", "=", "original_link", ".", "target", "neighbor_weight", "=", "original_link", ".", "weight", "feather_weight", "=", "neighbor_weight", "/", "node_weight_sum", "neighbor_node_weight_sum", "=", "sum", "(", "l", ".", "weight", "for", "l", "in", "neighbor_node", ".", "link_list", ")", "# Iterate over the links belonging to the neighbor_node,", "# copying its links to ``node`` with proportional weights", "for", "neighbor_link", "in", "neighbor_node", ".", "link_list", ":", "if", "(", "not", "include_self", ")", "and", "(", "neighbor_link", ".", "target", "==", "node", ")", ":", "continue", "relative_link_weight", "=", "(", "neighbor_link", ".", "weight", "/", "neighbor_node_weight_sum", ")", "feathered_link_weight", "=", "round", "(", "(", "relative_link_weight", "*", "feather_weight", "*", "factor", ")", ",", "2", ")", "node", ".", "add_link", "(", "neighbor_link", ".", "target", ",", "feathered_link_weight", ")", "for", "n", "in", "self", ".", "node_list", ":", "feather_node", "(", "n", ")" ]

[ "Feather", "the", "links", "of", "connected", "nodes", "." ]

[ "def", "sort", "(", "self", ")", ":", "# First sort commits by author email", "users", "=", "[", "]", "# Group commits by author email, so they can be merged", "for", "_", ",", "group", "in", "itertools", ".", "groupby", "(", "sorted", "(", "self", ".", "commits", ")", ",", "operator", ".", "attrgetter", "(", "'author_mail'", ")", ")", ":", "if", "group", ":", "users", ".", "append", "(", "self", ".", "merge_user_commits", "(", "group", ")", ")", "# Finally sort by the (aggregated) commits' line counts", "self", ".", "sorted_commits", "=", "sorted", "(", "users", ",", "key", "=", "operator", ".", "attrgetter", "(", "'line_count'", ")", ",", "reverse", "=", "True", ")", "return", "self", ".", "sorted_commits" ]

[ "Sort", "by", "commit", "size", "per", "author", "." ]

[ "def", "expectedLabelPosition", "(", "peptide", ",", "labelStateInfo", ",", "sequence", "=", "None", ",", "modPositions", "=", "None", ")", ":", "if", "modPositions", "is", "None", ":", "modPositions", "=", "maspy", ".", "peptidemethods", ".", "returnModPositions", "(", "peptide", ",", "indexStart", "=", "0", ")", "if", "sequence", "is", "None", ":", "sequence", "=", "maspy", ".", "peptidemethods", ".", "removeModifications", "(", "peptide", ")", "currLabelMods", "=", "dict", "(", ")", "for", "labelPosition", ",", "labelSymbols", "in", "viewitems", "(", "labelStateInfo", "[", "'aminoAcidLabels'", "]", ")", ":", "labelSymbols", "=", "aux", ".", "toList", "(", "labelSymbols", ")", "if", "labelSymbols", "==", "[", "''", "]", ":", "pass", "elif", "labelPosition", "==", "'nTerm'", ":", "currLabelMods", ".", "setdefault", "(", "0", ",", "list", "(", ")", ")", "currLabelMods", "[", "0", "]", ".", "extend", "(", "labelSymbols", ")", "else", ":", "for", "sequencePosition", "in", "aux", ".", "findAllSubstrings", "(", "sequence", ",", "labelPosition", ")", ":", "currLabelMods", ".", "setdefault", "(", "sequencePosition", ",", "list", "(", ")", ")", "currLabelMods", "[", "sequencePosition", "]", ".", "extend", "(", "labelSymbols", ")", "if", "labelStateInfo", "[", "'excludingModifications'", "]", "is", "not", "None", ":", "for", "excludingMod", ",", "excludedLabelSymbol", "in", "viewitems", "(", "labelStateInfo", "[", "'excludingModifications'", "]", ")", ":", "if", "excludingMod", "not", "in", "modPositions", ":", "continue", "for", "excludingModPos", "in", "modPositions", "[", "excludingMod", "]", ":", "if", "excludingModPos", "not", "in", "currLabelMods", ":", "continue", "if", "excludedLabelSymbol", "not", "in", "currLabelMods", "[", "excludingModPos", "]", ":", "continue", "if", "len", "(", "currLabelMods", "[", "excludingModPos", "]", ")", "==", "1", ":", "del", "(", "currLabelMods", "[", "excludingModPos", "]", ")", "else", ":", "excludedModIndex", "=", "currLabelMods", "[", "excludingModPos", "]", ".", "index", "(", "excludedLabelSymbol", ")", "currLabelMods", "[", "excludingModPos", "]", ".", "pop", "(", "excludedModIndex", ")", "for", "sequencePosition", "in", "list", "(", "viewkeys", "(", "currLabelMods", ")", ")", ":", "currLabelMods", "[", "sequencePosition", "]", "=", "sorted", "(", "currLabelMods", "[", "sequencePosition", "]", ")", "return", "currLabelMods" ]

[ "Returns", "a", "modification", "description", "of", "a", "certain", "label", "state", "of", "a", "peptide", "." ]

[ "def", "send", "(", "self", ",", "message_data", ",", "routing_key", "=", "None", ",", "delivery_mode", "=", "None", ",", "mandatory", "=", "False", ",", "immediate", "=", "False", ",", "priority", "=", "0", ",", "content_type", "=", "None", ",", "content_encoding", "=", "None", ",", "serializer", "=", "None", ",", "exchange", "=", "None", ")", ":", "headers", "=", "None", "routing_key", "=", "routing_key", "or", "self", ".", "routing_key", "if", "self", ".", "exchange_type", "==", "\"headers\"", ":", "headers", ",", "routing_key", "=", "routing_key", ",", "\"\"", "exchange", "=", "exchange", "or", "self", ".", "exchange", "message", "=", "self", ".", "create_message", "(", "message_data", ",", "priority", "=", "priority", ",", "delivery_mode", "=", "delivery_mode", ",", "content_type", "=", "content_type", ",", "content_encoding", "=", "content_encoding", ",", "serializer", "=", "serializer", ")", "self", ".", "backend", ".", "publish", "(", "message", ",", "exchange", "=", "exchange", ",", "routing_key", "=", "routing_key", ",", "mandatory", "=", "mandatory", ",", "immediate", "=", "immediate", ",", "headers", "=", "headers", ")" ]

[ "Send", "a", "message", "." ]

[ "def", "install_toolset", "(", "self", ",", "toolset", ")", ":", "info", "=", "toolset_info", "[", "toolset", "]", "if", "sys", ".", "platform", ".", "startswith", "(", "'linux'", ")", ":", "os", ".", "chdir", "(", "self", ".", "work_dir", ")", "if", "'ppa'", "in", "info", ":", "for", "ppa", "in", "info", "[", "'ppa'", "]", ":", "utils", ".", "check_call", "(", "'sudo'", ",", "'add-apt-repository'", ",", "'--yes'", ",", "ppa", ")", "if", "'deb'", "in", "info", ":", "utils", ".", "make_file", "(", "'sources.list'", ",", "\"deb %s\"", "%", "(", "' '", ".", "join", "(", "info", "[", "'deb'", "]", ")", ")", ",", "\"deb-src %s\"", "%", "(", "' '", ".", "join", "(", "info", "[", "'deb'", "]", ")", ")", ")", "utils", ".", "check_call", "(", "'sudo'", ",", "'bash'", ",", "'-c'", ",", "'cat sources.list >> /etc/apt/sources.list'", ")", "if", "'apt-key'", "in", "info", ":", "for", "key", "in", "info", "[", "'apt-key'", "]", ":", "utils", ".", "check_call", "(", "'wget'", ",", "key", ",", "'-O'", ",", "'apt.key'", ")", "utils", ".", "check_call", "(", "'sudo'", ",", "'apt-key'", ",", "'add'", ",", "'apt.key'", ")", "utils", ".", "check_call", "(", "'sudo'", ",", "'apt-get'", ",", "'update'", ",", "'-qq'", ")", "utils", ".", "check_call", "(", "'sudo'", ",", "'apt-get'", ",", "'install'", ",", "'-qq'", ",", "info", "[", "'package'", "]", ")", "if", "'debugpackage'", "in", "info", "and", "info", "[", "'debugpackage'", "]", ":", "utils", ".", "check_call", "(", "'sudo'", ",", "'apt-get'", ",", "'install'", ",", "'-qq'", ",", "info", "[", "'debugpackage'", "]", ")" ]

[ "Installs", "specific", "toolset", "on", "CI", "system", "." ]

[ "def", "quadrature_scheme_lognormal_gauss_hermite", "(", "loc", ",", "scale", ",", "quadrature_size", ",", "validate_args", "=", "False", ",", "name", "=", "None", ")", ":", "# pylint: disable=unused-argument", "with", "tf", ".", "name_scope", "(", "name", "or", "\"vector_diffeomixture_quadrature_gauss_hermite\"", ")", ":", "grid", ",", "probs", "=", "np", ".", "polynomial", ".", "hermite", ".", "hermgauss", "(", "deg", "=", "quadrature_size", ")", "npdt", "=", "dtype_util", ".", "as_numpy_dtype", "(", "loc", ".", "dtype", ")", "grid", "=", "grid", ".", "astype", "(", "npdt", ")", "probs", "=", "probs", ".", "astype", "(", "npdt", ")", "probs", "/=", "np", ".", "linalg", ".", "norm", "(", "probs", ",", "ord", "=", "1", ",", "keepdims", "=", "True", ")", "probs", "=", "tf", ".", "convert_to_tensor", "(", "value", "=", "probs", ",", "name", "=", "\"probs\"", ",", "dtype", "=", "loc", ".", "dtype", ")", "# The following maps the broadcast of `loc` and `scale` to each grid", "# point, i.e., we are creating several log-rates that correspond to the", "# different Gauss-Hermite quadrature points and (possible) batches of", "# `loc` and `scale`.", "grid", "=", "(", "loc", "[", "...", ",", "tf", ".", "newaxis", "]", "+", "np", ".", "sqrt", "(", "2.", ")", "*", "scale", "[", "...", ",", "tf", ".", "newaxis", "]", "*", "grid", ")", "return", "grid", ",", "probs" ]

[ "Use", "Gauss", "-", "Hermite", "quadrature", "to", "form", "quadrature", "on", "positive", "-", "reals", "." ]

[ "def", "id_from_url", "(", "url", ",", "param_name", ":", "str", ")", "->", "int", ":", "if", "url", "is", "None", ":", "raise", "ValueError", "(", "'url is none'", ")", "elif", "isinstance", "(", "url", ",", "int", ")", ":", "# Seems to already be the url.", "return", "url", "if", "not", "url", ":", "raise", "ValueError", "(", "'Seems to be empty'", ")", "try", ":", "return", "int", "(", "url", ")", "except", "ValueError", ":", "pass", "parsed", "=", "urlparse", "(", "url", ")", "try", ":", "resource_url", "=", "app", ".", "url_map", ".", "bind", "(", "parsed", ".", "netloc", ")", ".", "match", "(", "parsed", ".", "path", ")", "except", "NotFound", ":", "raise", "ValueError", "(", "'No URL found'", ")", "if", "param_name", "in", "resource_url", "[", "1", "]", ":", "return", "resource_url", "[", "1", "]", "[", "param_name", "]", "else", ":", "raise", "ValueError", "(", "'Parameter {name} could not be extracted'", ".", "format", "(", "name", "=", "param_name", ")", ")" ]

[ "Parses", "an", "object", "and", "tries", "to", "extract", "a", "url", ".", "Tries", "to", "parse", "if", "a", "resource_url", "has", "been", "given", "it", "as", "a", "url", ".", ":", "raise", "ValueError", ":", "If", "no", "id", "could", "be", "extracted", "." ]

[ "def", "update_req", "(", "req", ")", ":", "if", "not", "req", ".", "name", ":", "return", "req", ",", "None", "info", "=", "get_package_info", "(", "req", ".", "name", ")", "if", "info", "[", "'info'", "]", ".", "get", "(", "'_pypi_hidden'", ")", ":", "print", "(", "'{} is hidden on PyPI and will not be updated.'", ".", "format", "(", "req", ")", ")", "return", "req", ",", "None", "if", "_is_pinned", "(", "req", ")", "and", "_is_version_range", "(", "req", ")", ":", "print", "(", "'{} is pinned to a range and will not be updated.'", ".", "format", "(", "req", ")", ")", "return", "req", ",", "None", "newest_version", "=", "_get_newest_version", "(", "info", ")", "current_spec", "=", "next", "(", "iter", "(", "req", ".", "specifier", ")", ")", "if", "req", ".", "specifier", "else", "None", "current_version", "=", "current_spec", ".", "version", "if", "current_spec", "else", "None", "new_spec", "=", "Specifier", "(", "u'=={}'", ".", "format", "(", "newest_version", ")", ")", "if", "not", "current_spec", "or", "current_spec", ".", "_spec", "!=", "new_spec", ".", "_spec", ":", "req", ".", "specifier", "=", "new_spec", "update_info", "=", "(", "req", ".", "name", ",", "current_version", ",", "newest_version", ")", "return", "req", ",", "update_info", "return", "req", ",", "None" ]

[ "Updates", "a", "given", "req", "object", "with", "the", "latest", "version", "." ]

[ "def", "match", "(", "self", ",", "word", ")", ":", "# If the constraint has a custom function it must return True.", "if", "self", ".", "custom", "is", "not", "None", "and", "self", ".", "custom", "(", "word", ")", "is", "False", ":", "return", "False", "# If the constraint can only match the first word, Word.index must be 0.", "if", "self", ".", "first", "and", "word", ".", "index", ">", "0", ":", "return", "False", "# If the constraint defines excluded options, Word can not match any of these.", "if", "self", ".", "exclude", "and", "self", ".", "exclude", ".", "match", "(", "word", ")", ":", "return", "False", "# If the constraint defines allowed tags, Word.tag needs to match one of these.", "if", "self", ".", "tags", ":", "if", "find", "(", "lambda", "w", ":", "_match", "(", "word", ".", "tag", ",", "w", ")", ",", "self", ".", "tags", ")", "is", "None", ":", "return", "False", "# If the constraint defines allowed chunks, Word.chunk.tag needs to match one of these.", "if", "self", ".", "chunks", ":", "ch", "=", "word", ".", "chunk", "and", "word", ".", "chunk", ".", "tag", "or", "None", "if", "find", "(", "lambda", "w", ":", "_match", "(", "ch", ",", "w", ")", ",", "self", ".", "chunks", ")", "is", "None", ":", "return", "False", "# If the constraint defines allowed role, Word.chunk.tag needs to match one of these.", "if", "self", ".", "roles", ":", "R", "=", "word", ".", "chunk", "and", "[", "r2", "for", "r1", ",", "r2", "in", "word", ".", "chunk", ".", "relations", "]", "or", "[", "]", "if", "find", "(", "lambda", "w", ":", "w", "in", "R", ",", "self", ".", "roles", ")", "is", "None", ":", "return", "False", "# If the constraint defines allowed words,", "# Word.string.lower() OR Word.lemma needs to match one of these.", "b", "=", "True", "# b==True when word in constraint (or Constraints.words=[]).", "if", "len", "(", "self", ".", "words", ")", "+", "len", "(", "self", ".", "taxa", ")", ">", "0", ":", "s1", "=", "word", ".", "string", ".", "lower", "(", ")", "s2", "=", "word", ".", "lemma", "b", "=", "False", "for", "w", "in", "itertools", ".", "chain", "(", "self", ".", "words", ",", "self", ".", "taxa", ")", ":", "# If the constraint has a word with spaces (e.g., a proper noun),", "# compare it to the entire chunk.", "try", ":", "if", "\" \"", "in", "w", "and", "(", "s1", "in", "w", "or", "s2", "and", "s2", "in", "w", "or", "\"*\"", "in", "w", ")", ":", "s1", "=", "word", ".", "chunk", "and", "word", ".", "chunk", ".", "string", ".", "lower", "(", ")", "or", "s1", "s2", "=", "word", ".", "chunk", "and", "\" \"", ".", "join", "(", "[", "x", "or", "\"\"", "for", "x", "in", "word", ".", "chunk", ".", "lemmata", "]", ")", "or", "s2", "except", ":", "s1", "=", "s1", "s2", "=", "None", "# Compare the word to the allowed words (which can contain wildcards).", "if", "_match", "(", "s1", ",", "w", ")", ":", "b", "=", "True", "break", "# Compare the word lemma to the allowed words, e.g.,", "# if \"was\" is not in the constraint, perhaps \"be\" is, which is a good match.", "if", "s2", "and", "_match", "(", "s2", ",", "w", ")", ":", "b", "=", "True", "break", "# If the constraint defines allowed taxonomy terms,", "# and the given word did not match an allowed word, traverse the taxonomy.", "# The search goes up from the given word to its parents in the taxonomy.", "# This is faster than traversing all the children of terms in Constraint.taxa.", "# The drawback is that:", "# 1) Wildcards in the taxonomy are not detected (use classifiers instead),", "# 2) Classifier.children() has no effect, only Classifier.parent().", "if", "self", ".", "taxa", "and", "(", "not", "self", ".", "words", "or", "(", "self", ".", "words", "and", "not", "b", ")", ")", ":", "for", "s", "in", "(", "word", ".", "string", ",", "# \"ants\"", "word", ".", "lemma", ",", "# \"ant\"", "word", ".", "chunk", "and", "word", ".", "chunk", ".", "string", "or", "None", ",", "# \"army ants\"", "word", ".", "chunk", "and", "\" \"", ".", "join", "(", "[", "x", "or", "\"\"", "for", "x", "in", "word", ".", "chunk", ".", "lemmata", "]", ")", "or", "None", ")", ":", "# \"army ant\"", "if", "s", "is", "not", "None", ":", "if", "self", ".", "taxonomy", ".", "case_sensitive", "is", "False", ":", "s", "=", "s", ".", "lower", "(", ")", "# Compare ancestors of the word to each term in Constraint.taxa.", "for", "p", "in", "self", ".", "taxonomy", ".", "parents", "(", "s", ",", "recursive", "=", "True", ")", ":", "if", "find", "(", "lambda", "s", ":", "p", "==", "s", ",", "self", ".", "taxa", ")", ":", "# No wildcards.", "return", "True", "return", "b" ]

[ "Return", "True", "if", "the", "given", "Word", "is", "part", "of", "the", "constraint", ":", "-", "the", "word", "(", "or", "lemma", ")", "occurs", "in", "Constraint", ".", "words", "OR", "-", "the", "word", "(", "or", "lemma", ")", "occurs", "in", "Constraint", ".", "taxa", "taxonomy", "tree", "AND", "-", "the", "word", "and", "/", "or", "chunk", "tags", "match", "those", "defined", "in", "the", "constraint", ".", "Individual", "terms", "in", "Constraint", ".", "words", "or", "the", "taxonomy", "can", "contain", "wildcards", "(", "*", ")", ".", "Some", "part", "-", "of", "-", "speech", "-", "tags", "can", "also", "contain", "wildcards", ":", "NN", "*", "VB", "*", "JJ", "*", "RB", "*", "If", "the", "given", "word", "contains", "spaces", "(", "e", ".", "g", ".", "proper", "noun", ")", "the", "entire", "chunk", "will", "also", "be", "compared", ".", "For", "example", ":", "Constraint", "(", "words", "=", "[", "Mac", "OS", "X", "*", "]", ")", "matches", "the", "word", "Mac", "if", "the", "word", "occurs", "in", "a", "Chunk", "(", "Mac", "OS", "X", "10", ".", "5", ")", "." ]

[ "def", "file_name", "(", "self", ",", "file_name", ")", ":", "if", "not", "self", ".", "can_update", "(", ")", ":", "self", ".", "_tcex", ".", "handle_error", "(", "910", ",", "[", "self", ".", "type", "]", ")", "self", ".", "_data", "[", "'fileName'", "]", "=", "file_name", "request", "=", "{", "'fileName'", ":", "file_name", "}", "return", "self", ".", "tc_requests", ".", "update", "(", "self", ".", "api_type", ",", "self", ".", "api_sub_type", ",", "self", ".", "unique_id", ",", "request", ")" ]

[ "Updates", "the", "file_name", "." ]

[ "def", "flush", "(", "self", ",", "table", ")", ":", "table_path", "=", "os", ".", "path", ".", "join", "(", "self", ".", "db_path", ",", "table", ")", "if", "os", ".", "path", ".", "exists", "(", "table_path", ")", ":", "os", ".", "unlink", "(", "table_path", ")" ]

[ "Flush", "table", "." ]

[ "def", "astype", "(", "self", ",", "dtype", ")", ":", "dtype", "=", "np", ".", "dtype", "(", "dtype", ")", "filters", "=", "[", "]", "if", "self", ".", "_filters", ":", "filters", ".", "extend", "(", "self", ".", "_filters", ")", "filters", ".", "insert", "(", "0", ",", "AsType", "(", "encode_dtype", "=", "self", ".", "_dtype", ",", "decode_dtype", "=", "dtype", ")", ")", "return", "self", ".", "view", "(", "filters", "=", "filters", ",", "dtype", "=", "dtype", ",", "read_only", "=", "True", ")" ]

[ "Returns", "a", "view", "that", "does", "on", "the", "fly", "type", "conversion", "of", "the", "underlying", "data", "." ]

[ "def", "_update_params", "(", "self", ",", "constants", ")", ":", "constants", "=", "np", ".", "max", "(", "np", ".", "min", "(", "constants", ",", "1", ")", ")", "self", ".", "params", "[", "'r'", "]", "[", "'value'", "]", "=", "max", "(", "[", "self", ".", "params", "[", "'r'", "]", "[", "'value'", "]", ",", "constants", "]", ")", "epsilon", "=", "constants", "/", "self", ".", "params", "[", "'r'", "]", "[", "'value'", "]", "influence", "=", "self", ".", "_calculate_influence", "(", "epsilon", ")", "# Account for learning rate", "return", "influence", "*", "epsilon" ]

[ "Update", "the", "params", "." ]

[ "def", "build_delete_node_by_hash", "(", "manager", ":", "Manager", ")", "->", "Callable", "[", "[", "BELGraph", ",", "str", "]", ",", "None", "]", ":", "@", "in_place_transformation", "def", "delete_node_by_hash", "(", "graph", ":", "BELGraph", ",", "node_hash", ":", "str", ")", "->", "None", ":", "\"\"\"Remove a node by identifier.\"\"\"", "node", "=", "manager", ".", "get_dsl_by_hash", "(", "node_hash", ")", "graph", ".", "remove_node", "(", "node", ")", "return", "delete_node_by_hash" ]

[ "Make", "a", "delete", "function", "that", "s", "bound", "to", "the", "manager", "." ]

[ "def", "disable_notebook", "(", ")", ":", "try", ":", "from", "IPython", ".", "core", ".", "getipython", "import", "get_ipython", "except", "ImportError", ":", "raise", "ImportError", "(", "'This feature requires IPython 1.0+'", ")", "ip", "=", "get_ipython", "(", ")", "f", "=", "ip", ".", "display_formatter", ".", "formatters", "[", "'text/html'", "]", "f", ".", "type_printers", ".", "pop", "(", "np", ".", "ndarray", ",", "None", ")" ]

[ "Disable", "automatic", "visualization", "of", "NumPy", "arrays", "in", "the", "IPython", "Notebook", "." ]

[ "def", "__convert_env", "(", "env", ",", "encoding", ")", ":", "d", "=", "dict", "(", "os", ".", "environ", ",", "*", "*", "(", "oget", "(", "env", ",", "{", "}", ")", ")", ")", "# workaround for Windows+Python3 environment", "if", "not", "SHOULD_NOT_ENCODE_ARGS", ":", "return", "dict", "(", "(", "k", ".", "encode", "(", "encoding", ")", ",", "v", ".", "encode", "(", "encoding", ")", ")", "for", "k", ",", "v", "in", "d", ".", "items", "(", ")", ")", "else", ":", "return", "d" ]

[ "Environment", "variables", "should", "be", "bytes", "not", "unicode", "on", "Windows", "." ]

[ "def", "dplptree2dgparentedtree", "(", "self", ")", ":", "def", "transform", "(", "dplp_tree", ")", ":", "\"\"\"Transform a DPLP parse tree into a more conventional parse tree.\"\"\"", "if", "isinstance", "(", "dplp_tree", ",", "basestring", ")", "or", "not", "hasattr", "(", "dplp_tree", ",", "'label'", ")", ":", "return", "dplp_tree", "assert", "len", "(", "dplp_tree", ")", "==", "2", ",", "\"We can only handle binary trees.\"", "match", "=", "DPLP_REL_RE", ".", "match", "(", "dplp_tree", ".", "label", "(", ")", ")", "assert", "match", ",", "\"Relation '{}' does not match regex '{}'\"", ".", "format", "(", "dplp_tree", ".", "label", "(", ")", ",", "DPLP_REL_RE", ")", "left_child_nuc", ",", "right_child_nuc", ",", "relname", "=", "match", ".", "groups", "(", ")", "dplp_tree", ".", "_label", "=", "relname", "for", "i", ",", "child_nuclearity", "in", "enumerate", "(", "[", "left_child_nuc", ",", "right_child_nuc", "]", ")", ":", "child", "=", "dplp_tree", "[", "i", "]", "dplp_tree", "[", "i", "]", "=", "Tree", "(", "child_nuclearity", ",", "[", "transform", "(", "child", ")", "]", ")", "return", "dplp_tree", "tree", "=", "transform", "(", "self", ".", "parsetree", ")", "return", "DGParentedTree", ".", "convert", "(", "tree", ")" ]

[ "Convert", "the", "tree", "from", "DPLP", "s", "format", "into", "a", "conventional", "binary", "tree", "which", "can", "be", "easily", "converted", "into", "output", "formats", "like", "RS3", "." ]

[ "def", "everything", "(", "self", ",", "include_deleted", "=", "False", ",", "content_id", "=", "None", ",", "subtopic_id", "=", "None", ",", "prefix", "=", "None", ")", ":", "if", "content_id", "is", "not", "None", ":", "ranges", "=", "[", "(", "(", "content_id", ",", ")", ",", "(", "content_id", ",", ")", ")", "]", "elif", "prefix", "is", "not", "None", ":", "# This is the cheap, easy, and wrong way to do this", "ranges", "=", "[", "(", "(", "prefix", ",", ")", ",", "(", "prefix", "+", "b'\\xff'", ",", ")", ")", "]", "else", ":", "ranges", "=", "[", "]", "labels", "=", "self", ".", "kvl", ".", "scan", "(", "self", ".", "TABLE", ",", "*", "ranges", ")", "labels", "=", "ifilter", "(", "self", ".", "_filter_keys", "(", "content_id", ",", "prefix", ",", "subtopic_id", ")", ",", "labels", ")", "labels", "=", "imap", "(", "lambda", "p", ":", "self", ".", "_label_from_kvlayer", "(", "*", "p", ")", ",", "labels", ")", "if", "not", "include_deleted", ":", "labels", "=", "Label", ".", "most_recent", "(", "labels", ")", "return", "labels" ]

[ "Returns", "a", "generator", "of", "all", "labels", "in", "the", "store", "." ]

[ "def", "generated_tag_data", "(", "tags", ")", ":", "generated_tags", "=", "[", "]", "for", "key", ",", "value", "in", "tags", ".", "items", "(", ")", ":", "generated_tags", ".", "append", "(", "{", "'Key'", ":", "key", ",", "'Value'", ":", "value", ",", "}", ")", "return", "generated_tags" ]

[ "Convert", ":", "obj", ":", "dict", "to", "S3", "Tag", "list", "." ]

[ "def", "create", "(", "output_prefix", ",", "grid_flux_filename", ",", "wavelength_filenames", ",", "clobber", "=", "False", ",", "grid_flux_filename_format", "=", "\"csv\"", ",", "*", "*", "kwargs", ")", ":", "if", "not", "clobber", ":", "# Check to make sure the output files won't exist already.", "output_suffixes", "=", "(", "\".yaml\"", ",", "\".pkl\"", ",", "\"-wavelengths.memmap\"", ",", "\"-intensities.memmap\"", ")", "for", "path", "in", "[", "output_prefix", "+", "suffix", "for", "suffix", "in", "output_suffixes", "]", ":", "if", "os", ".", "path", ".", "exists", "(", "path", ")", ":", "raise", "IOError", "(", "\"output filename {} already exists\"", ".", "format", "(", "path", ")", ")", "# Read the grid_flux filename.", "# param1 param2 param3 param4 channelname1 channelname2", "kwds", "=", "kwargs", ".", "pop", "(", "\"__grid_flux_filename_kwargs\"", ",", "{", "}", ")", "kwds", ".", "update", "(", "{", "\"format\"", ":", "grid_flux_filename_format", "}", ")", "grid_flux_tbl", "=", "Table", ".", "read", "(", "grid_flux_filename", ",", "*", "*", "kwds", ")", "# Distinguish column names between parameters (real numbers) and filenames", "str_columns", "=", "np", ".", "array", "(", "[", "_", "[", "1", "]", ".", "startswith", "(", "\"|S\"", ")", "for", "_", "in", "grid_flux_tbl", ".", "dtype", ".", "descr", "]", ")", "# Check the number of channels provided.", "if", "str_columns", ".", "sum", "(", ")", "!=", "len", "(", "wavelength_filenames", ")", ":", "raise", "ValueError", "(", "\"expected {0} wavelength filenames because {1} has {0}\"", "\" string columns ({2}) but found {3} wavelength filenames\"", ".", "format", "(", "sum", "(", "str_columns", ")", ",", "grid_flux_filename", ",", "\", \"", ".", "join", "(", "np", ".", "array", "(", "grid_flux_tbl", ".", "colnames", ")", "[", "str_columns", "]", ")", ",", "len", "(", "wavelength_filenames", ")", ")", ")", "# Create a record array of the grid points.", "grid_points", "=", "grid_flux_tbl", ".", "as_array", "(", ")", "[", "np", ".", "array", "(", "grid_flux_tbl", ".", "colnames", ")", "[", "~", "str_columns", "]", "]", "# To-do: make sure they are all floats.", "# Sort the grid points.", "grid_indices", "=", "grid_points", ".", "argsort", "(", "order", "=", "grid_points", ".", "dtype", ".", "names", ")", "grid_points", "=", "grid_points", "[", "grid_indices", "]", "grid_flux_tbl", "=", "grid_flux_tbl", "[", "grid_indices", "]", "# Check the wavelength filenames.", "channel_wavelengths", "=", "np", ".", "array", "(", "map", "(", "load_simple_data", ",", "wavelength_filenames", ")", ")", "# Sort the channels by starting wavelength.", "c_indices", "=", "np", ".", "argsort", "(", "[", "each", ".", "min", "(", ")", "for", "each", "in", "channel_wavelengths", "]", ")", "channel_names", "=", "np", ".", "array", "(", "grid_flux_tbl", ".", "colnames", ")", "[", "str_columns", "]", "[", "c_indices", "]", "channel_wavelengths", "=", "channel_wavelengths", "[", "c_indices", "]", "channel_sizes", "=", "[", "len", "(", "_", ")", "for", "_", "in", "channel_wavelengths", "]", "num_pixels", "=", "sum", "(", "channel_sizes", ")", "# Create the model YAML file.", "with", "open", "(", "output_prefix", "+", "\".yaml\"", ",", "\"w\"", ")", "as", "fp", ":", "header", "=", "\"\\n\"", ".", "join", "(", "[", "\"# Model created on {0}\"", ".", "format", "(", "strftime", "(", "\"%Y-%m-%d %H:%M:%S\"", ")", ")", ",", "\"# Grid parameters: {0}\"", ".", "format", "(", "\", \"", ".", "join", "(", "grid_points", ".", "dtype", ".", "names", ")", ")", ",", "\"# Channel names: {0}\"", ".", "format", "(", "\", \"", ".", "join", "(", "channel_names", ")", ")", "]", ")", "fp", ".", "write", "(", "header", "+", "\"\\n\"", "+", "yaml", ".", "safe_dump", "(", "{", "\"model_grid\"", ":", "{", "\"grid_points\"", ":", "output_prefix", "+", "\".pkl\"", ",", "\"intensities\"", ":", "output_prefix", "+", "\"-intensities.memmap\"", ",", "\"wavelengths\"", ":", "output_prefix", "+", "\"-wavelengths.memmap\"", "}", "}", ",", "stream", "=", "None", ",", "allow_unicode", "=", "True", ",", "default_flow_style", "=", "False", ")", ")", "# Create the pickled model file, with meta data.", "metadata", "=", "{", "\"grid_flux_filename\"", ":", "grid_flux_filename", ",", "\"wavelength_filenames\"", ":", "wavelength_filenames", ",", "\"channel_names\"", ":", "channel_names", ",", "\"channel_sizes\"", ":", "channel_sizes", ",", "\"channel_resolutions\"", ":", "[", "float", "(", "\"inf\"", ")", "]", "*", "len", "(", "channel_names", ")", ",", "\"sick_version\"", ":", "sick_version", "}", "logger", ".", "debug", "(", "\"Dumping grid points and metadata to file\"", ")", "with", "open", "(", "output_prefix", "+", "\".pkl\"", ",", "\"wb\"", ")", "as", "fp", ":", "pickle", ".", "dump", "(", "(", "grid_points", ",", "metadata", ")", ",", "fp", ",", "-", "1", ")", "# Create the memory-mapped dispersion file.", "logger", ".", "debug", "(", "\"Creating memory-mapped dispersion file.\"", ")", "wavelengths_memmap", "=", "np", ".", "memmap", "(", "output_prefix", "+", "\"-wavelengths.memmap\"", ",", "dtype", "=", "\"float32\"", ",", "mode", "=", "\"w+\"", ",", "shape", "=", "(", "num_pixels", ",", ")", ")", "wavelengths_memmap", "[", ":", "]", "=", "np", ".", "hstack", "(", "channel_wavelengths", ")", "wavelengths_memmap", ".", "flush", "(", ")", "del", "wavelengths_memmap", "# Create the memory-mapped intensities file.", "logger", ".", "debug", "(", "\"Creating memory-mapped intensities file.\"", ")", "intensities_memmap", "=", "np", ".", "memmap", "(", "output_prefix", "+", "\"-intensities.memmap\"", ",", "shape", "=", "(", "grid_points", ".", "size", ",", "num_pixels", ")", ",", "dtype", "=", "\"float32\"", ",", "mode", "=", "\"w+\"", ")", "n", "=", "len", "(", "grid_flux_tbl", ")", "for", "i", ",", "row", "in", "enumerate", "(", "grid_flux_tbl", ")", ":", "logger", ".", "debug", "(", "\"Loading point {0}/{1} into the intensities map\"", ".", "format", "(", "i", "+", "1", ",", "n", ")", ")", "j", "=", "0", "for", "channel_name", "in", "channel_names", ":", "try", ":", "data", "=", "load_simple_data", "(", "row", "[", "channel_name", "]", ")", "except", ":", "logger", ".", "exception", "(", "\"Could not load data from {0} for channel {1}\"", ".", "format", "(", "row", "[", "channel_name", "]", ",", "channel_name", ")", ")", "raise", "intensities_memmap", "[", "i", ",", "j", ":", "j", "+", "data", ".", "size", "]", "=", "data", "j", "+=", "data", ".", "size", "intensities_memmap", ".", "flush", "(", ")", "del", "intensities_memmap", "return", "True" ]

[ "Create", "a", "new", "*", "sick", "*", "model", "from", "files", "describing", "the", "parameter", "names", "fluxes", "and", "wavelengths", "." ]

[ "def", "visit_IfExp", "(", "self", ",", "node", ":", "ast", ".", "IfExp", ")", "->", "Any", ":", "test", "=", "self", ".", "visit", "(", "node", "=", "node", ".", "test", ")", "if", "test", ":", "result", "=", "self", ".", "visit", "(", "node", "=", "node", ".", "body", ")", "else", ":", "result", "=", "self", ".", "visit", "(", "node", "=", "node", ".", "orelse", ")", "self", ".", "recomputed_values", "[", "node", "]", "=", "result", "return", "result" ]

[ "Visit", "the", "test", "and", "depending", "on", "its", "outcome", "the", "body", "or", "orelse", "." ]

[ "def", "compute", "(", "self", ",", "now", ",", "x", ",", "y", ",", "angle", ")", ":", "# Normalize angle to [-180,180]", "output", "=", "[", "]", "angle", "=", "(", "(", "angle", "+", "math", ".", "pi", ")", "%", "(", "math", ".", "pi", "*", "2", ")", ")", "-", "math", ".", "pi", "for", "target", "in", "self", ".", "targets", ":", "proposed", "=", "target", ".", "compute", "(", "now", ",", "x", ",", "y", ",", "angle", ")", "if", "proposed", ":", "output", ".", "append", "(", "proposed", ")", "if", "not", "output", ":", "output", ".", "append", "(", "(", "0", ",", "now", ",", "inf", ",", "0", ")", ")", "self", ".", "distance", "=", "None", "else", ":", "# order by absolute offset", "output", ".", "sort", "(", "key", "=", "lambda", "i", ":", "abs", "(", "i", "[", "2", "]", ")", ")", "self", ".", "distance", "=", "output", "[", "-", "1", "]", "[", "3", "]", "# Only store stuff every once in awhile", "if", "now", "-", "self", ".", "last_compute_time", ">", "self", ".", "update_period", ":", "self", ".", "last_compute_time", "=", "now", "self", ".", "send_queue", ".", "appendleft", "(", "output", ")", "# simulate latency by delaying camera output", "if", "self", ".", "send_queue", ":", "output", "=", "self", ".", "send_queue", "[", "-", "1", "]", "if", "now", "-", "output", "[", "0", "]", "[", "1", "]", ">", "self", ".", "data_lag", ":", "return", "self", ".", "send_queue", ".", "pop", "(", ")" ]

[ "Call", "this", "when", "vision", "processing", "should", "be", "enabled", ":", "param", "now", ":", "The", "value", "passed", "to", "update_sim", ":", "param", "x", ":", "Returned", "from", "physics_controller", ".", "get_position", ":", "param", "y", ":", "Returned", "from", "physics_controller", ".", "get_position", ":", "param", "angle", ":", "Returned", "from", "physics_controller", ".", "get_position", ":", "returns", ":", "None", "or", "list", "of", "tuples", "of", "(", "found", "=", "0", "or", "1", "capture_time", "offset_degrees", "distance", ")", ".", "The", "tuples", "are", "ordered", "by", "absolute", "offset", "from", "the", "target", ".", "If", "a", "list", "is", "returned", "it", "is", "guaranteed", "to", "have", "at", "least", "one", "element", "in", "it", ".", "Note", ":", "If", "your", "vision", "targeting", "doesn", "t", "have", "the", "ability", "to", "focus", "on", "multiple", "targets", "then", "you", "should", "ignore", "the", "other", "elements", "." ]

[ "def", "access_token_response", "(", "self", ",", "access_token", ")", ":", "response_data", "=", "{", "'access_token'", ":", "access_token", ".", "token", ",", "'token_type'", ":", "constants", ".", "TOKEN_TYPE", ",", "'expires_in'", ":", "access_token", ".", "get_expire_delta", "(", ")", ",", "'scope'", ":", "' '", ".", "join", "(", "scope", ".", "names", "(", "access_token", ".", "scope", ")", ")", ",", "}", "# Not all access_tokens are given a refresh_token", "# (for example, public clients doing password auth)", "try", ":", "rt", "=", "access_token", ".", "refresh_token", "response_data", "[", "'refresh_token'", "]", "=", "rt", ".", "token", "except", "ObjectDoesNotExist", ":", "pass", "return", "HttpResponse", "(", "json", ".", "dumps", "(", "response_data", ")", ",", "mimetype", "=", "'application/json'", ")" ]

[ "Returns", "a", "successful", "response", "after", "creating", "the", "access", "token", "as", "defined", "in", ":", "rfc", ":", "5", ".", "1", "." ]

[ "def", "debug_contents", "(", "self", ",", "indent", "=", "1", ",", "file", "=", "sys", ".", "stdout", ",", "_ids", "=", "None", ")", ":", "if", "_debug", ":", "_log", ".", "debug", "(", "\"debug_contents indent=%r file=%r _ids=%r\"", ",", "indent", ",", "file", ",", "_ids", ")", "klasses", "=", "list", "(", "self", ".", "__class__", ".", "__mro__", ")", "klasses", ".", "reverse", "(", ")", "if", "_debug", ":", "_log", ".", "debug", "(", "\" - klasses: %r\"", ",", "klasses", ")", "# loop through the classes and look for _debug_contents", "attrs", "=", "[", "]", "cids", "=", "[", "]", "ownFn", "=", "[", "]", "for", "klass", "in", "klasses", ":", "if", "klass", "is", "DebugContents", ":", "continue", "if", "not", "issubclass", "(", "klass", ",", "DebugContents", ")", "and", "hasattr", "(", "klass", ",", "'debug_contents'", ")", ":", "for", "i", ",", "seenAlready", "in", "enumerate", "(", "ownFn", ")", ":", "if", "issubclass", "(", "klass", ",", "seenAlready", ")", ":", "del", "ownFn", "[", "i", "]", "break", "ownFn", ".", "append", "(", "klass", ")", "continue", "# look for a tuple of attribute names", "if", "not", "hasattr", "(", "klass", ",", "'_debug_contents'", ")", ":", "continue", "debugContents", "=", "klass", ".", "_debug_contents", "if", "not", "isinstance", "(", "debugContents", ",", "tuple", ")", ":", "raise", "RuntimeError", "(", "\"%s._debug_contents must be a tuple\"", "%", "(", "klass", ".", "__name__", ",", ")", ")", "# already seen it?", "if", "id", "(", "debugContents", ")", "in", "cids", ":", "continue", "cids", ".", "append", "(", "id", "(", "debugContents", ")", ")", "for", "attr", "in", "debugContents", ":", "if", "attr", "not", "in", "attrs", ":", "attrs", ".", "append", "(", "attr", ")", "# a bit of debugging", "if", "_debug", ":", "_log", ".", "debug", "(", "\" - attrs: %r\"", ",", "attrs", ")", "_log", ".", "debug", "(", "\" - ownFn: %r\"", ",", "ownFn", ")", "# make/extend the list of objects already seen", "if", "_ids", "is", "None", ":", "_ids", "=", "[", "]", "# loop through the attributes", "for", "attr", "in", "attrs", ":", "# assume you're going deep, but not into lists and dicts", "goDeep", "=", "True", "goListDict", "=", "False", "goHexed", "=", "False", "# attribute list might want to go deep", "if", "attr", ".", "endswith", "(", "\"-\"", ")", ":", "goDeep", "=", "False", "attr", "=", "attr", "[", ":", "-", "1", "]", "elif", "attr", ".", "endswith", "(", "\"*\"", ")", ":", "goHexed", "=", "True", "attr", "=", "attr", "[", ":", "-", "1", "]", "elif", "attr", ".", "endswith", "(", "\"+\"", ")", ":", "goDeep", "=", "False", "goListDict", "=", "True", "attr", "=", "attr", "[", ":", "-", "1", "]", "if", "attr", ".", "endswith", "(", "\"+\"", ")", ":", "goDeep", "=", "True", "attr", "=", "attr", "[", ":", "-", "1", "]", "value", "=", "getattr", "(", "self", ",", "attr", ",", "None", ")", "# skip None", "if", "value", "is", "None", ":", "continue", "# standard output", "if", "goListDict", "and", "isinstance", "(", "value", ",", "list", ")", "and", "value", ":", "file", ".", "write", "(", "\"%s%s = [\\n\"", "%", "(", "' '", "*", "indent", ",", "attr", ")", ")", "indent", "+=", "1", "for", "i", ",", "elem", "in", "enumerate", "(", "value", ")", ":", "file", ".", "write", "(", "\"%s[%d] %r\\n\"", "%", "(", "' '", "*", "indent", ",", "i", ",", "elem", ")", ")", "if", "goDeep", "and", "hasattr", "(", "elem", ",", "'debug_contents'", ")", ":", "if", "id", "(", "elem", ")", "not", "in", "_ids", ":", "_ids", ".", "append", "(", "id", "(", "elem", ")", ")", "elem", ".", "debug_contents", "(", "indent", "+", "1", ",", "file", ",", "_ids", ")", "indent", "-=", "1", "file", ".", "write", "(", "\"%s ]\\n\"", "%", "(", "' '", "*", "indent", ",", ")", ")", "elif", "goListDict", "and", "isinstance", "(", "value", ",", "dict", ")", "and", "value", ":", "file", ".", "write", "(", "\"%s%s = {\\n\"", "%", "(", "' '", "*", "indent", ",", "attr", ")", ")", "indent", "+=", "1", "for", "key", ",", "elem", "in", "value", ".", "items", "(", ")", ":", "file", ".", "write", "(", "\"%s%r : %r\\n\"", "%", "(", "' '", "*", "indent", ",", "key", ",", "elem", ")", ")", "if", "goDeep", "and", "hasattr", "(", "elem", ",", "'debug_contents'", ")", ":", "if", "id", "(", "elem", ")", "not", "in", "_ids", ":", "_ids", ".", "append", "(", "id", "(", "elem", ")", ")", "elem", ".", "debug_contents", "(", "indent", "+", "1", ",", "file", ",", "_ids", ")", "indent", "-=", "1", "file", ".", "write", "(", "\"%s }\\n\"", "%", "(", "' '", "*", "indent", ",", ")", ")", "elif", "goHexed", "and", "isinstance", "(", "value", ",", "str", ")", ":", "if", "len", "(", "value", ")", ">", "20", ":", "hexed", "=", "btox", "(", "value", "[", ":", "20", "]", ",", "'.'", ")", "+", "\"...\"", "else", ":", "hexed", "=", "btox", "(", "value", ",", "'.'", ")", "file", ".", "write", "(", "\"%s%s = x'%s'\\n\"", "%", "(", "' '", "*", "indent", ",", "attr", ",", "hexed", ")", ")", "# elif goHexed and isinstance(value, int):", "# file.write(\"%s%s = 0x%X\\n\" % (' ' * indent, attr, value))", "else", ":", "file", ".", "write", "(", "\"%s%s = %r\\n\"", "%", "(", "' '", "*", "indent", ",", "attr", ",", "value", ")", ")", "# go nested if it is debugable", "if", "goDeep", "and", "hasattr", "(", "value", ",", "'debug_contents'", ")", ":", "if", "id", "(", "value", ")", "not", "in", "_ids", ":", "_ids", ".", "append", "(", "id", "(", "value", ")", ")", "value", ".", "debug_contents", "(", "indent", "+", "1", ",", "file", ",", "_ids", ")", "# go through the functions", "ownFn", ".", "reverse", "(", ")", "for", "klass", "in", "ownFn", ":", "klass", ".", "debug_contents", "(", "self", ",", "indent", ",", "file", ",", "_ids", ")" ]

[ "Debug", "the", "contents", "of", "an", "object", "." ]

[ "def", "sphergal_to_rectgal", "(", "l", ",", "b", ",", "d", ",", "vr", ",", "pmll", ",", "pmbb", ",", "degree", "=", "False", ")", ":", "XYZ", "=", "lbd_to_XYZ", "(", "l", ",", "b", ",", "d", ",", "degree", "=", "degree", ")", "vxvyvz", "=", "vrpmllpmbb_to_vxvyvz", "(", "vr", ",", "pmll", ",", "pmbb", ",", "l", ",", "b", ",", "d", ",", "XYZ", "=", "False", ",", "degree", "=", "degree", ")", "if", "sc", ".", "array", "(", "l", ")", ".", "shape", "==", "(", ")", ":", "return", "sc", ".", "array", "(", "[", "XYZ", "[", "0", "]", ",", "XYZ", "[", "1", "]", ",", "XYZ", "[", "2", "]", ",", "vxvyvz", "[", "0", "]", ",", "vxvyvz", "[", "1", "]", ",", "vxvyvz", "[", "2", "]", "]", ")", "else", ":", "out", "=", "sc", ".", "zeros", "(", "(", "len", "(", "l", ")", ",", "6", ")", ")", "out", "[", ":", ",", "0", ":", "3", "]", "=", "XYZ", "out", "[", ":", ",", "3", ":", "6", "]", "=", "vxvyvz", "return", "out" ]

[ "NAME", ":" ]

[ "def", "__set_config", "(", "self", ",", "cfg_section", ")", ":", "defaults", "=", "[", "'shutit.core.alerting.emailer.mailto'", ",", "None", ",", "'shutit.core.alerting.emailer.mailfrom'", ",", "'[email protected]'", ",", "'shutit.core.alerting.emailer.smtp_server'", ",", "'localhost'", ",", "'shutit.core.alerting.emailer.smtp_port'", ",", "25", ",", "'shutit.core.alerting.emailer.use_tls'", ",", "True", ",", "'shutit.core.alerting.emailer.send_mail'", ",", "True", ",", "'shutit.core.alerting.emailer.subject'", ",", "'Shutit Report'", ",", "'shutit.core.alerting.emailer.signature'", ",", "'--Angry Shutit'", ",", "'shutit.core.alerting.emailer.compress'", ",", "True", ",", "'shutit.core.alerting.emailer.username'", ",", "''", ",", "'shutit.core.alerting.emailer.password'", ",", "''", ",", "'shutit.core.alerting.emailer.safe_mode'", ",", "True", ",", "'shutit.core.alerting.emailer.maintainer'", ",", "''", ",", "'shutit.core.alerting.emailer.mailto_maintainer'", ",", "True", "]", "for", "cfg_name", ",", "cfg_default", "in", "zip", "(", "defaults", "[", "0", ":", ":", "2", "]", ",", "defaults", "[", "1", ":", ":", "2", "]", ")", ":", "try", ":", "self", ".", "config", "[", "cfg_name", "]", "=", "self", ".", "shutit", ".", "cfg", "[", "cfg_section", "]", "[", "cfg_name", "]", "except", "KeyError", ":", "if", "cfg_default", "is", "None", ":", "raise", "Exception", "(", "cfg_section", "+", "' '", "+", "cfg_name", "+", "' must be set'", ")", "else", ":", "self", ".", "config", "[", "cfg_name", "]", "=", "cfg_default", "# only send a mail to the module's maintainer if configured correctly", "if", "self", ".", "config", "[", "'shutit.core.alerting.emailer.mailto_maintainer'", "]", "and", "(", "self", ".", "config", "[", "'shutit.core.alerting.emailer.maintainer'", "]", "==", "\"\"", "or", "self", ".", "config", "[", "'shutit.core.alerting.emailer.maintainer'", "]", "==", "self", ".", "config", "[", "'shutit.core.alerting.emailer.mailto'", "]", ")", ":", "self", ".", "config", "[", "'shutit.core.alerting.emailer.mailto_maintainer'", "]", "=", "False", "self", ".", "config", "[", "'shutit.core.alerting.emailer.maintainer'", "]", "=", "\"\"" ]

[ "Set", "a", "local", "config", "array", "up", "according", "to", "defaults", "and", "main", "shutit", "configuration" ]

[ "def", "load_conditions", "(", "self", ",", "filename", "=", "None", ")", ":", "if", "self", ".", "hasconditions", ":", "if", "not", "filename", ":", "filename", "=", "self", ".", "_conditiondefaultfilename", "namespace", "=", "locals", "(", ")", "for", "seq", "in", "self", ".", "conditionsequences", ":", "namespace", "[", "seq", ".", "name", "]", "=", "seq", "namespace", "[", "'model'", "]", "=", "self", "code", "=", "hydpy", ".", "pub", ".", "conditionmanager", ".", "load_file", "(", "filename", ")", "try", ":", "# ToDo: raises an escape sequence deprecation sometimes", "# ToDo: use runpy instead?", "# ToDo: Move functionality to filetools.py?", "exec", "(", "code", ")", "except", "BaseException", ":", "objecttools", ".", "augment_excmessage", "(", "'While trying to gather initial conditions of element %s'", "%", "objecttools", ".", "devicename", "(", "self", ")", ")" ]

[ "Read", "the", "initial", "conditions", "from", "a", "file", "and", "assign", "them", "to", "the", "respective", "|StateSequence|", "and", "/", "or", "|LogSequence|", "objects", "handled", "by", "the", "actual", "|Sequences|", "object", "." ]

[ "def", "_from_proto_sparse_tensor", "(", "sparse_tensor_proto", ",", "process_leafs", ")", ":", "if", "not", "sparse_tensor_proto", ".", "HasField", "(", "\"named_tuple\"", ")", ":", "raise", "base_errors", ".", "ModuleInfoError", "(", "\"Error while deserializing a SparseTensor: expected proto tuple.\"", ")", "if", "sparse_tensor_proto", ".", "named_tuple", ".", "name", "!=", "_SPARSE_TENSOR_NAME", ":", "raise", "base_errors", ".", "ModuleInfoError", "(", "\"Error while deserializing a SparseTensor: The name of the tuple \"", "\"should have been {} but was {}.\"", ".", "format", "(", "_SPARSE_TENSOR_NAME", ",", "sparse_tensor_proto", ".", "named_tuple", ".", "name", ")", ")", "named_tuple_map", "=", "sparse_tensor_proto", ".", "named_tuple", ".", "map", "return", "tf", ".", "SparseTensor", "(", "indices", "=", "process_leafs", "(", "named_tuple_map", "[", "\"indices\"", "]", ".", "value", ")", ",", "values", "=", "process_leafs", "(", "named_tuple_map", "[", "\"values\"", "]", ".", "value", ")", ",", "dense_shape", "=", "process_leafs", "(", "named_tuple_map", "[", "\"dense_shape\"", "]", ".", "value", ")", ")" ]

[ "Deserializes", "a", "tf", ".", "SparseTensor", "from", "sparse_tensor_proto", "." ]

[ "def", "_laplace_fit", "(", "self", ",", "obj_type", ")", ":", "# Get Mode and Inverse Hessian information", "y", "=", "self", ".", "fit", "(", "method", "=", "'PML'", ",", "printer", "=", "False", ")", "if", "y", ".", "ihessian", "is", "None", ":", "raise", "Exception", "(", "\"No Hessian information - Laplace approximation cannot be performed\"", ")", "else", ":", "self", ".", "latent_variables", ".", "estimation_method", "=", "'Laplace'", "theta", ",", "Y", ",", "scores", ",", "states", ",", "states_var", ",", "X_names", "=", "self", ".", "_categorize_model_output", "(", "self", ".", "latent_variables", ".", "get_z_values", "(", ")", ")", "# Change this in future", "try", ":", "latent_variables_store", "=", "self", ".", "latent_variables", ".", "copy", "(", ")", "except", ":", "latent_variables_store", "=", "self", ".", "latent_variables", "return", "LaplaceResults", "(", "data_name", "=", "self", ".", "data_name", ",", "X_names", "=", "X_names", ",", "model_name", "=", "self", ".", "model_name", ",", "model_type", "=", "self", ".", "model_type", ",", "latent_variables", "=", "latent_variables_store", ",", "data", "=", "Y", ",", "index", "=", "self", ".", "index", ",", "multivariate_model", "=", "self", ".", "multivariate_model", ",", "objective_object", "=", "obj_type", ",", "method", "=", "'Laplace'", ",", "ihessian", "=", "y", ".", "ihessian", ",", "signal", "=", "theta", ",", "scores", "=", "scores", ",", "z_hide", "=", "self", ".", "_z_hide", ",", "max_lag", "=", "self", ".", "max_lag", ",", "states", "=", "states", ",", "states_var", "=", "states_var", ")" ]

[ "Performs", "a", "Laplace", "approximation", "to", "the", "posterior" ]

[ "def", "update_from", "(", "self", ",", "mapping", ")", ":", "for", "key", ",", "value", "in", "mapping", ".", "items", "(", ")", ":", "if", "key", "in", "self", ":", "if", "isinstance", "(", "value", ",", "Parameter", ")", ":", "value", "=", "value", ".", "value", "self", "[", "key", "]", ".", "value", "=", "value" ]

[ "Updates", "the", "set", "of", "parameters", "from", "a", "mapping", "for", "keys", "that", "already", "exist" ]

[ "def", "get_func_argument_types", "(", "self", ",", "hsh", ":", "bytes", ")", ":", "if", "not", "isinstance", "(", "hsh", ",", "(", "bytes", ",", "bytearray", ")", ")", ":", "raise", "TypeError", "(", "'The selector argument must be a concrete byte array'", ")", "sig", "=", "self", ".", "_function_signatures_by_selector", ".", "get", "(", "hsh", ")", "return", "'()'", "if", "sig", "is", "None", "else", "sig", "[", "sig", ".", "find", "(", "'('", ")", ":", "]" ]

[ "Returns", "the", "tuple", "type", "signature", "for", "the", "arguments", "of", "the", "function", "associated", "with", "the", "selector", "hsh", "." ]

[ "def", "_is_significant", "(", "change", ",", "significance", ")", ":", "try", ":", "a", "=", "float", "(", "change", "[", "'from'", "]", ")", "b", "=", "float", "(", "change", "[", "'to'", "]", ")", "except", "ValueError", ":", "return", "True", "return", "abs", "(", "a", "-", "b", ")", ">", "10", "**", "(", "-", "significance", ")" ]

[ "Return", "True", "if", "a", "change", "is", "genuinely", "significant", "given", "our", "tolerance", "." ]

[ "def", "train", "(", "self", ",", "text", ",", "className", ")", ":", "self", ".", "data", ".", "increaseClass", "(", "className", ")", "tokens", "=", "self", ".", "tokenizer", ".", "tokenize", "(", "text", ")", "for", "token", "in", "tokens", ":", "token", "=", "self", ".", "tokenizer", ".", "remove_stop_words", "(", "token", ")", "token", "=", "self", ".", "tokenizer", ".", "remove_punctuation", "(", "token", ")", "self", ".", "data", ".", "increaseToken", "(", "token", ",", "className", ")" ]

[ "enhances", "trained", "data", "using", "the", "given", "text", "and", "class" ]

[ "def", "decode_modified_utf8", "(", "s", ":", "bytes", ")", "->", "str", ":", "s", "=", "bytearray", "(", "s", ")", "buff", "=", "[", "]", "buffer_append", "=", "buff", ".", "append", "ix", "=", "0", "while", "ix", "<", "len", "(", "s", ")", ":", "x", "=", "s", "[", "ix", "]", "ix", "+=", "1", "if", "x", ">>", "7", "==", "0", ":", "# Just an ASCII character, nothing else to do.", "pass", "elif", "x", ">>", "6", "==", "6", ":", "y", "=", "s", "[", "ix", "]", "ix", "+=", "1", "x", "=", "(", "(", "x", "&", "0x1F", ")", "<<", "6", ")", "+", "(", "y", "&", "0x3F", ")", "elif", "x", ">>", "4", "==", "14", ":", "y", ",", "z", "=", "s", "[", "ix", ":", "ix", "+", "2", "]", "ix", "+=", "2", "x", "=", "(", "(", "x", "&", "0xF", ")", "<<", "12", ")", "+", "(", "(", "y", "&", "0x3F", ")", "<<", "6", ")", "+", "(", "z", "&", "0x3F", ")", "elif", "x", "==", "0xED", ":", "v", ",", "w", ",", "x", ",", "y", ",", "z", "=", "s", "[", "ix", ":", "ix", "+", "6", "]", "ix", "+=", "5", "x", "=", "0x10000", "+", "(", "(", "(", "v", "&", "0x0F", ")", "<<", "16", ")", "+", "(", "(", "w", "&", "0x3F", ")", "<<", "10", ")", "+", "(", "(", "y", "&", "0x0F", ")", "<<", "6", ")", "+", "(", "z", "&", "0x3F", ")", ")", "elif", "x", "==", "0xC0", "and", "s", "[", "ix", "]", "==", "0x80", ":", "ix", "+=", "1", "x", "=", "0", "buffer_append", "(", "x", ")", "return", "u''", ".", "join", "(", "chr", "(", "b", ")", "for", "b", "in", "buff", ")" ]

[ "Decodes", "a", "bytestring", "containing", "modified", "UTF", "-", "8", "as", "defined", "in", "section", "4", ".", "4", ".", "7", "of", "the", "JVM", "specification", "." ]

[ "def", "__SetTotal", "(", "self", ",", "info", ")", ":", "if", "'content-range'", "in", "info", ":", "_", ",", "_", ",", "total", "=", "info", "[", "'content-range'", "]", ".", "rpartition", "(", "'/'", ")", "if", "total", "!=", "'*'", ":", "self", ".", "__total_size", "=", "int", "(", "total", ")", "# Note \"total_size is None\" means we don't know it; if no size", "# info was returned on our initial range request, that means we", "# have a 0-byte file. (That last statement has been verified", "# empirically, but is not clearly documented anywhere.)", "if", "self", ".", "total_size", "is", "None", ":", "self", ".", "__total_size", "=", "0" ]

[ "Sets", "the", "total", "size", "based", "off", "info", "if", "possible", "otherwise", "0", "." ]

[ "def", "to_rectified", "(", "self", ",", "x", ",", "y", ")", ":", "return", "self", ".", "_reproject", "(", "self", ".", "wcs_original", ",", "self", ".", "wcs_rectified", ")", "(", "x", ",", "y", ")" ]

[ "Convert", "the", "input", "(", "x", "y", ")", "positions", "from", "the", "original", "(", "unrectified", ")", "image", "to", "the", "rectified", "image", "." ]

[ "def", "resendFaxRN", "(", "self", ",", "CorpNum", ",", "OrgRequestNum", ",", "SenderNum", ",", "SenderName", ",", "ReceiverNum", ",", "ReceiverName", ",", "ReserveDT", "=", "None", ",", "UserID", "=", "None", ",", "title", "=", "None", ",", "RequestNum", "=", "None", ")", ":", "receivers", "=", "None", "if", "ReceiverNum", "!=", "\"\"", "or", "ReceiverName", "!=", "\"\"", ":", "receivers", "=", "[", "]", "receivers", ".", "append", "(", "FaxReceiver", "(", "receiveNum", "=", "ReceiverNum", ",", "receiveName", "=", "ReceiverName", ")", ")", "return", "self", ".", "resendFaxRN_multi", "(", "CorpNum", ",", "OrgRequestNum", ",", "SenderNum", ",", "SenderName", ",", "receivers", ",", "ReserveDT", ",", "UserID", ",", "title", ",", "RequestNum", ")" ]

[ "팩스", "단건", "전송", "args", "CorpNum", ":", "팝빌회원", "사업자번호", "OrgRequestNum", ":", "원본", "팩스", "전송시", "할당한", "전송요청번호", "ReceiptNum", ":", "팩스", "접수번호", "SenderNum", ":", "발신자", "번호", "SenderName", ":", "발신자명", "ReceiverNum", ":", "수신번호", "ReceiverName", ":", "수신자명", "ReserveDT", ":", "예약시간", "(", "형식", "yyyyMMddHHmmss", ")", "UserID", ":", "팝빌회원", "아이디", "title", ":", "팩스제목", "RequestNum", ":", "전송요청시", "할당한", "전송요청번호", "return", "접수번호", "(", "receiptNum", ")", "raise", "PopbillException" ]

[ "def", "resolve_redirects", "(", "self", ",", "resp", ",", "req", ",", "stream", "=", "False", ",", "timeout", "=", "None", ",", "verify", "=", "True", ",", "cert", "=", "None", ",", "proxies", "=", "None", ")", ":", "i", "=", "0", "hist", "=", "[", "]", "# keep track of history", "while", "resp", ".", "is_redirect", ":", "prepared_request", "=", "req", ".", "copy", "(", ")", "if", "i", ">", "0", ":", "# Update history and keep track of redirects.", "hist", ".", "append", "(", "resp", ")", "new_hist", "=", "list", "(", "hist", ")", "resp", ".", "history", "=", "new_hist", "try", ":", "resp", ".", "content", "# Consume socket so it can be released", "except", "(", "ChunkedEncodingError", ",", "ContentDecodingError", ",", "RuntimeError", ")", ":", "resp", ".", "raw", ".", "read", "(", "decode_content", "=", "False", ")", "if", "i", ">=", "self", ".", "max_redirects", ":", "raise", "TooManyRedirects", "(", "'Exceeded %s redirects.'", "%", "self", ".", "max_redirects", ")", "# Release the connection back into the pool.", "resp", ".", "close", "(", ")", "url", "=", "resp", ".", "headers", "[", "'location'", "]", "method", "=", "req", ".", "method", "# Handle redirection without scheme (see: RFC 1808 Section 4)", "if", "url", ".", "startswith", "(", "'//'", ")", ":", "parsed_rurl", "=", "urlparse", "(", "resp", ".", "url", ")", "url", "=", "'%s:%s'", "%", "(", "parsed_rurl", ".", "scheme", ",", "url", ")", "# The scheme should be lower case...", "parsed", "=", "urlparse", "(", "url", ")", "url", "=", "parsed", ".", "geturl", "(", ")", "# Facilitate relative 'location' headers, as allowed by RFC 7231.", "# (e.g. '/path/to/resource' instead of 'http://domain.tld/path/to/resource')", "# Compliant with RFC3986, we percent encode the url.", "if", "not", "parsed", ".", "netloc", ":", "url", "=", "urljoin", "(", "resp", ".", "url", ",", "requote_uri", "(", "url", ")", ")", "else", ":", "url", "=", "requote_uri", "(", "url", ")", "prepared_request", ".", "url", "=", "to_native_string", "(", "url", ")", "# Cache the url, unless it redirects to itself.", "if", "resp", ".", "is_permanent_redirect", "and", "req", ".", "url", "!=", "prepared_request", ".", "url", ":", "self", ".", "redirect_cache", "[", "req", ".", "url", "]", "=", "prepared_request", ".", "url", "# http://tools.ietf.org/html/rfc7231#section-6.4.4", "if", "(", "resp", ".", "status_code", "==", "codes", ".", "see_other", "and", "method", "!=", "'HEAD'", ")", ":", "method", "=", "'GET'", "# Do what the browsers do, despite standards...", "# First, turn 302s into GETs.", "if", "resp", ".", "status_code", "==", "codes", ".", "found", "and", "method", "!=", "'HEAD'", ":", "method", "=", "'GET'", "# Second, if a POST is responded to with a 301, turn it into a GET.", "# This bizarre behaviour is explained in Issue 1704.", "if", "resp", ".", "status_code", "==", "codes", ".", "moved", "and", "method", "==", "'POST'", ":", "method", "=", "'GET'", "prepared_request", ".", "method", "=", "method", "# https://github.com/kennethreitz/requests/issues/1084", "if", "resp", ".", "status_code", "not", "in", "(", "codes", ".", "temporary_redirect", ",", "codes", ".", "permanent_redirect", ")", ":", "if", "'Content-Length'", "in", "prepared_request", ".", "headers", ":", "del", "prepared_request", ".", "headers", "[", "'Content-Length'", "]", "prepared_request", ".", "body", "=", "None", "headers", "=", "prepared_request", ".", "headers", "try", ":", "del", "headers", "[", "'Cookie'", "]", "except", "KeyError", ":", "pass", "# Extract any cookies sent on the response to the cookiejar", "# in the new request. Because we've mutated our copied prepared", "# request, use the old one that we haven't yet touched.", "extract_cookies_to_jar", "(", "prepared_request", ".", "_cookies", ",", "req", ",", "resp", ".", "raw", ")", "prepared_request", ".", "_cookies", ".", "update", "(", "self", ".", "cookies", ")", "prepared_request", ".", "prepare_cookies", "(", "prepared_request", ".", "_cookies", ")", "# Rebuild auth and proxy information.", "proxies", "=", "self", ".", "rebuild_proxies", "(", "prepared_request", ",", "proxies", ")", "self", ".", "rebuild_auth", "(", "prepared_request", ",", "resp", ")", "# Override the original request.", "req", "=", "prepared_request", "resp", "=", "self", ".", "send", "(", "req", ",", "stream", "=", "stream", ",", "timeout", "=", "timeout", ",", "verify", "=", "verify", ",", "cert", "=", "cert", ",", "proxies", "=", "proxies", ",", "allow_redirects", "=", "False", ",", ")", "extract_cookies_to_jar", "(", "self", ".", "cookies", ",", "prepared_request", ",", "resp", ".", "raw", ")", "i", "+=", "1", "yield", "resp" ]

[ "Receives", "a", "Response", ".", "Returns", "a", "generator", "of", "Responses", "." ]

[ "def", "get_db_driver", "(", "uri", ",", "username", "=", "None", ",", "password", "=", "None", ",", "encrypted", "=", "True", ",", "max_pool_size", "=", "50", ",", "trust", "=", "0", ")", ":", "return", "GraphDatabase", ".", "driver", "(", "uri", ",", "auth", "=", "basic_auth", "(", "username", ",", "password", ")", ",", "encrypted", "=", "encrypted", ",", "max_pool_size", "=", "max_pool_size", ",", "trust", "=", "trust", ")" ]

[ ":", "param", "uri", ":", "Bolt", "uri", ":", "type", "uri", ":", "str", ":", "param", "username", ":", "Neo4j", "username", ":", "type", "username", ":", "str", ":", "param", "password", ":", "Neo4j", "password", ":", "type", "password", ":", "str", ":", "param", "encrypted", ":", "Use", "TLS", ":", "type", "encrypted", ":", "Boolean", ":", "param", "max_pool_size", ":", "Maximum", "number", "of", "idle", "sessions", ":", "type", "max_pool_size", ":", "Integer", ":", "param", "trust", ":", "Trust", "cert", "on", "first", "use", "(", "0", ")", "or", "do", "not", "accept", "unknown", "cert", "(", "1", ")", ":", "type", "trust", ":", "Integer", ":", "return", ":", "Neo4j", "driver", ":", "rtype", ":", "neo4j", ".", "v1", ".", "session", ".", "Driver" ]

[ "def", "where", "(", "self", ",", "inplace", "=", "False", ",", "*", "*", "kwargs", ")", ":", "masks", "=", "{", "k", ":", "np", ".", "ones", "(", "v", ",", "dtype", "=", "'bool'", ")", "for", "k", ",", "v", "in", "self", ".", "dimensions", ".", "items", "(", ")", "}", "def", "index_to_mask", "(", "index", ",", "n", ")", ":", "val", "=", "np", ".", "zeros", "(", "n", ",", "dtype", "=", "'bool'", ")", "val", "[", "index", "]", "=", "True", "return", "val", "def", "masks_and", "(", "dict1", ",", "dict2", ")", ":", "return", "{", "k", ":", "dict1", "[", "k", "]", "&", "index_to_mask", "(", "dict2", "[", "k", "]", ",", "len", "(", "dict1", "[", "k", "]", ")", ")", "for", "k", "in", "dict1", "}", "for", "key", "in", "kwargs", ":", "value", "=", "kwargs", "[", "key", "]", "if", "key", ".", "endswith", "(", "'_index'", ")", ":", "if", "isinstance", "(", "value", ",", "int", ")", ":", "value", "=", "[", "value", "]", "dim", "=", "key", "[", ":", "-", "len", "(", "'_index'", ")", "]", "m", "=", "self", ".", "_propagate_dim", "(", "value", ",", "dim", ")", "masks", "=", "masks_and", "(", "masks", ",", "m", ")", "else", ":", "attribute", "=", "self", ".", "get_attribute", "(", "key", ")", "if", "isinstance", "(", "value", ",", "list", ")", ":", "mask", "=", "reduce", "(", "operator", ".", "or_", ",", "[", "attribute", ".", "value", "==", "m", "for", "m", "in", "value", "]", ")", "else", ":", "mask", "=", "attribute", ".", "value", "==", "value", "m", "=", "self", ".", "_propagate_dim", "(", "mask", ",", "attribute", ".", "dim", ")", "masks", "=", "masks_and", "(", "masks", ",", "m", ")", "return", "masks" ]

[ "Return", "indices", "over", "every", "dimension", "that", "met", "the", "conditions", ".", "Condition", "syntax", ":", "*", "attribute", "*", "=", "value", "Return", "indices", "that", "satisfy", "the", "condition", "where", "the", "attribute", "is", "equal", "to", "the", "value", "e", ".", "g", ".", "type_array", "=", "H", "*", "attribute", "*", "=", "list", "(", "value1", "value2", ")", "Return", "indices", "that", "satisfy", "the", "condition", "where", "the", "attribute", "is", "equal", "to", "any", "of", "the", "value", "in", "the", "list", ".", "e", ".", "g", ".", "type_array", "=", "[", "H", "O", "]", "*", "dimension_index", "*", "=", "value", ":", "int", "*", "dimension_index", "*", "=", "value", ":", "list", "(", "int", ")", "Return", "only", "elements", "that", "correspond", "to", "the", "index", "in", "the", "specified", "dimension", ":", "atom_index", "=", "0", "atom_index", "=", "[", "0", "1", "]" ]

[ "def", "integrations", "(", "since", ",", "to", ",", "write", ",", "force", ")", ":", "agent_tags", "=", "get_agent_tags", "(", "since", ",", "to", ")", "# get the list of integrations shipped with the agent from the requirements file", "req_file_name", "=", "os", ".", "path", ".", "basename", "(", "get_agent_release_requirements", "(", ")", ")", "integrations_contents", "=", "StringIO", "(", ")", "for", "tag", "in", "agent_tags", ":", "integrations_contents", ".", "write", "(", "'## Datadog Agent version {}\\n\\n'", ".", "format", "(", "tag", ")", ")", "# Requirements for current tag", "file_contents", "=", "git_show_file", "(", "req_file_name", ",", "tag", ")", "for", "name", ",", "ver", "in", "iteritems", "(", "parse_agent_req_file", "(", "file_contents", ")", ")", ":", "integrations_contents", ".", "write", "(", "'* {}: {}\\n'", ".", "format", "(", "name", ",", "ver", ")", ")", "integrations_contents", ".", "write", "(", "'\\n'", ")", "# save the changelog on disk if --write was passed", "if", "write", ":", "dest", "=", "get_agent_integrations_file", "(", ")", "# don't overwrite an existing file", "if", "os", ".", "path", ".", "exists", "(", "dest", ")", "and", "not", "force", ":", "msg", "=", "\"Output file {} already exists, run the command again with --force to overwrite\"", "abort", "(", "msg", ".", "format", "(", "dest", ")", ")", "write_file", "(", "dest", ",", "integrations_contents", ".", "getvalue", "(", ")", ")", "else", ":", "echo_info", "(", "integrations_contents", ".", "getvalue", "(", ")", ")" ]

[ "Generates", "a", "markdown", "file", "containing", "the", "list", "of", "integrations", "shipped", "in", "a", "given", "Agent", "release", ".", "Agent", "version", "numbers", "are", "derived", "inspecting", "tags", "on", "integrations", "-", "core", "so", "running", "this", "tool", "might", "provide", "unexpected", "results", "if", "the", "repo", "is", "not", "up", "to", "date", "with", "the", "Agent", "release", "process", "." ]

[ "def", "AddService", "(", "self", ",", "new_service", ")", ":", "for", "service", "in", "self", ".", "_services", ":", "if", "new_service", "==", "service", ":", "# If this service is the same as one we already know about, we", "# just want to add where it came from.", "service", ".", "sources", ".", "append", "(", "new_service", ".", "sources", "[", "0", "]", ")", "return", "# We only add a new object to our list if we don't have", "# an identical one already.", "self", ".", "_services", ".", "append", "(", "new_service", ")" ]

[ "Add", "a", "new", "service", "to", "the", "list", "of", "ones", "we", "know", "about", "." ]

[ "def", "find_by_client", "(", "cls", ",", "from_client", ",", "limit", "=", "None", ",", "before_time", "=", "None", ",", "before_message_id", "=", "None", ")", ":", "# type: (str, Optional[int], Optional[Union[datetime, float]], Optional[str]) -> List[Message]", "query_params", "=", "{", "}", "# type: Dict[str, Any]", "query_params", "[", "'from'", "]", "=", "from_client", "if", "limit", "is", "not", "None", ":", "query_params", "[", "'limit'", "]", "=", "limit", "if", "isinstance", "(", "before_time", ",", "datetime", ")", ":", "query_params", "[", "'max_ts'", "]", "=", "round", "(", "before_time", ".", "timestamp", "(", ")", "*", "1000", ")", "elif", "isinstance", "(", "before_time", ",", "six", ".", "integer_types", ")", "or", "isinstance", "(", "before_time", ",", "float", ")", ":", "query_params", "[", "'max_ts'", "]", "=", "round", "(", "before_time", "*", "1000", ")", "if", "before_message_id", "is", "not", "None", ":", "query_params", "[", "'msgid'", "]", "=", "before_message_id", "return", "list", "(", "cls", ".", "_find", "(", "query_params", ")", ")" ]

[ "获取某个", "client", "的聊天记录" ]

[ "def", "MOV", "(", "self", ",", "params", ")", ":", "Rx", ",", "Ry", "=", "self", ".", "get_two_parameters", "(", "self", ".", "TWO_PARAMETER_COMMA_SEPARATED", ",", "params", ")", "self", ".", "check_arguments", "(", "any_registers", "=", "(", "Rx", ",", "Ry", ")", ")", "def", "MOV_func", "(", ")", ":", "self", ".", "register", "[", "Rx", "]", "=", "self", ".", "register", "[", "Ry", "]", "return", "MOV_func" ]

[ "MOV", "Rx", "Ry", "MOV", "PC", "Ry" ]

[ "def", "device_id_from_name", "(", "device_name", ",", "nodes", ")", ":", "device_id", "=", "None", "for", "node", "in", "nodes", ":", "if", "device_name", "==", "node", "[", "'properties'", "]", "[", "'name'", "]", ":", "device_id", "=", "node", "[", "'id'", "]", "break", "return", "device_id" ]

[ "Get", "the", "device", "ID", "when", "given", "a", "device", "name" ]

[ "def", "DictToAdditionalPropertyMessage", "(", "properties", ",", "additional_property_type", ",", "sort_items", "=", "False", ")", ":", "items", "=", "properties", ".", "items", "(", ")", "if", "sort_items", ":", "items", "=", "sorted", "(", "items", ")", "map_", "=", "[", "]", "for", "key", ",", "value", "in", "items", ":", "map_", ".", "append", "(", "additional_property_type", ".", "AdditionalProperty", "(", "key", "=", "key", ",", "value", "=", "value", ")", ")", "return", "additional_property_type", "(", "additionalProperties", "=", "map_", ")" ]

[ "Convert", "the", "given", "dictionary", "to", "an", "AdditionalProperty", "message", "." ]

[ "def", "validate_pluginid", "(", "value", ")", ":", "valid", "=", "string", ".", "ascii_letters", "+", "string", ".", "digits", "+", "'.'", "return", "all", "(", "c", "in", "valid", "for", "c", "in", "value", ")" ]

[ "Returns", "True", "if", "the", "provided", "value", "is", "a", "valid", "pluglin", "id" ]

[ "def", "_get_profile", "(", "self", ",", "user_account", ")", ":", "try", ":", "# TODO: Load active profile, not just any", "user_profile", "=", "objectmodels", "[", "'profile'", "]", ".", "find_one", "(", "{", "'owner'", ":", "str", "(", "user_account", ".", "uuid", ")", "}", ")", "self", ".", "log", "(", "\"Profile: \"", ",", "user_profile", ",", "user_account", ".", "uuid", ",", "lvl", "=", "debug", ")", "except", "Exception", "as", "e", ":", "self", ".", "log", "(", "\"No profile due to error: \"", ",", "e", ",", "type", "(", "e", ")", ",", "lvl", "=", "error", ")", "user_profile", "=", "None", "if", "not", "user_profile", ":", "default", "=", "{", "'uuid'", ":", "std_uuid", "(", ")", ",", "'owner'", ":", "user_account", ".", "uuid", ",", "'userdata'", ":", "{", "'notes'", ":", "'Default profile of '", "+", "user_account", ".", "name", "}", "}", "user_profile", "=", "objectmodels", "[", "'profile'", "]", "(", "default", ")", "user_profile", ".", "save", "(", ")", "return", "user_profile" ]

[ "Retrieves", "a", "user", "s", "profile" ]

[ "def", "install", "(", "runas", "=", "None", ",", "path", "=", "None", ")", ":", "path", "=", "path", "or", "_pyenv_path", "(", "runas", ")", "path", "=", "os", ".", "path", ".", "expanduser", "(", "path", ")", "return", "_install_pyenv", "(", "path", ",", "runas", ")" ]

[ "Install", "pyenv", "systemwide" ]

[ "def", "_type_description", "(", "self", ")", ":", "#This is a little tricker because the docstring is housed", "#inside of the module that contains the actual executable.", "#These TypeExecutables are just pointers.", "iexec", "=", "self", ".", "_element", ".", "target", "if", "iexec", "is", "not", "None", ":", "result", "=", "\"method() | \"", "+", "iexec", ".", "summary", "else", ":", "result", "=", "\"Type Method: points to executable in module.\"", "return", "result" ]

[ "Gets", "the", "completion", "description", "for", "a", "TypeExecutable", "." ]

[ "def", "filter", "(", "self", ",", "*", "*", "kwargs", ")", ":", "if", "not", "len", "(", "self", ")", ":", "self", ".", "all", "(", ")", "new_list", "=", "filter", "(", "lambda", "item", ":", "[", "True", "for", "arg", "in", "kwargs", "if", "item", "[", "arg", "]", "==", "kwargs", "[", "arg", "]", "]", "!=", "[", "]", ",", "self", ")", "return", "Profiles", "(", "self", ".", "api", ",", "new_list", ")" ]

[ "Based", "on", "some", "criteria", "filter", "the", "profiles", "and", "return", "a", "new", "Profiles", "Manager", "containing", "only", "the", "chosen", "items" ]

[ "def", "check_password", "(", "raw_password", ",", "enc_password", ")", ":", "l", "=", "enc_password", ".", "split", "(", "'$'", ")", "#only password of built-in user can split to 3\r", "if", "len", "(", "l", ")", "==", "3", ":", "algo", ",", "salt", ",", "hsh", "=", "l", "return", "hsh", "==", "get_hexdigest", "(", "algo", ",", "salt", ",", "raw_password", ")", "else", ":", "return", "False" ]

[ "Returns", "a", "boolean", "of", "whether", "the", "raw_password", "was", "correct", ".", "Handles", "encryption", "formats", "behind", "the", "scenes", "." ]

[ "def", "_add_modifiers", "(", "self", ",", "sql", ",", "blueprint", ",", "column", ")", ":", "for", "modifier", "in", "self", ".", "_modifiers", ":", "method", "=", "'_modify_%s'", "%", "modifier", "if", "hasattr", "(", "self", ",", "method", ")", ":", "sql", "+=", "getattr", "(", "self", ",", "method", ")", "(", "blueprint", ",", "column", ")", "return", "sql" ]

[ "Add", "the", "column", "modifiers", "to", "the", "deifinition" ]

[ "def", "execute", "(", "self", ",", "cacheable", "=", "False", ")", ":", "if", "self", ".", "network", ".", "is_caching_enabled", "(", ")", "and", "cacheable", ":", "response", "=", "self", ".", "_get_cached_response", "(", ")", "else", ":", "response", "=", "self", ".", "_download_response", "(", ")", "return", "minidom", ".", "parseString", "(", "_string", "(", "response", ")", ".", "replace", "(", "\"opensearch:\"", ",", "\"\"", ")", ")" ]

[ "Returns", "the", "XML", "DOM", "response", "of", "the", "POST", "Request", "from", "the", "server" ]

[ "def", "add_app_template_filter", "(", "self", ",", "func", ":", "Callable", ",", "name", ":", "Optional", "[", "str", "]", "=", "None", ")", "->", "None", ":", "self", ".", "record_once", "(", "lambda", "state", ":", "state", ".", "register_template_filter", "(", "func", ",", "name", ")", ")" ]

[ "Add", "an", "application", "wide", "template", "filter", "." ]

[ "def", "state", "(", "self", ",", "value", ")", ":", "self", ".", "_state", "=", "value", "self", ".", "state_changed", ".", "emit", "(", "value", ")" ]

[ "set", "player", "state", "emit", "state", "changed", "signal" ]

[ "def", "_start", "(", "self", ",", "worker", "=", "None", ")", ":", "if", "worker", ":", "self", ".", "_queue_workers", ".", "append", "(", "worker", ")", "if", "self", ".", "_queue_workers", "and", "self", ".", "_running_threads", "<", "self", ".", "_max_threads", ":", "#print('Queue: {0} Running: {1} Workers: {2} '", "# 'Threads: {3}'.format(len(self._queue_workers),", "# self._running_threads,", "# len(self._workers),", "# len(self._threads)))", "self", ".", "_running_threads", "+=", "1", "worker", "=", "self", ".", "_queue_workers", ".", "popleft", "(", ")", "thread", "=", "QThread", "(", ")", "if", "isinstance", "(", "worker", ",", "PythonWorker", ")", ":", "worker", ".", "moveToThread", "(", "thread", ")", "worker", ".", "sig_finished", ".", "connect", "(", "thread", ".", "quit", ")", "thread", ".", "started", ".", "connect", "(", "worker", ".", "_start", ")", "thread", ".", "start", "(", ")", "elif", "isinstance", "(", "worker", ",", "ProcessWorker", ")", ":", "thread", ".", "quit", "(", ")", "worker", ".", "_start", "(", ")", "self", ".", "_threads", ".", "append", "(", "thread", ")", "else", ":", "self", ".", "_timer", ".", "start", "(", ")", "if", "self", ".", "_workers", ":", "for", "w", "in", "self", ".", "_workers", ":", "if", "w", ".", "is_finished", "(", ")", ":", "self", ".", "_bag_collector", ".", "append", "(", "w", ")", "self", ".", "_workers", ".", "remove", "(", "w", ")", "if", "self", ".", "_threads", ":", "for", "t", "in", "self", ".", "_threads", ":", "if", "t", ".", "isFinished", "(", ")", ":", "self", ".", "_threads", ".", "remove", "(", "t", ")", "self", ".", "_running_threads", "-=", "1", "if", "len", "(", "self", ".", "_threads", ")", "==", "0", "and", "len", "(", "self", ".", "_workers", ")", "==", "0", ":", "self", ".", "_timer", ".", "stop", "(", ")", "self", ".", "_timer_worker_delete", ".", "start", "(", ")" ]

[ "Start", "threads", "and", "check", "for", "inactive", "workers", "." ]

[ "def", "downsample_grid", "(", "a", ",", "b", ",", "samples", ",", "ret_idx", "=", "False", ")", ":", "# fixed random state for this method", "rs", "=", "np", ".", "random", ".", "RandomState", "(", "seed", "=", "47", ")", ".", "get_state", "(", ")", "samples", "=", "int", "(", "samples", ")", "if", "samples", "and", "samples", "<", "a", ".", "size", ":", "# The events to keep", "keep", "=", "np", ".", "zeros_like", "(", "a", ",", "dtype", "=", "bool", ")", "# 1. Produce evenly distributed samples", "# Choosing grid-size:", "# - large numbers tend to show actual structures of the sample,", "# which is not desired for plotting", "# - small numbers tend will not result in too few samples and,", "# in order to reach the desired samples, the data must be", "# upsampled again.", "# 300 is about the size of the plot in marker sizes and yields", "# good results.", "grid_size", "=", "300", "xpx", "=", "norm", "(", "a", ",", "a", ",", "b", ")", "*", "grid_size", "ypx", "=", "norm", "(", "b", ",", "b", ",", "a", ")", "*", "grid_size", "# The events on the grid to process", "toproc", "=", "np", ".", "ones", "(", "(", "grid_size", ",", "grid_size", ")", ",", "dtype", "=", "bool", ")", "for", "ii", "in", "range", "(", "xpx", ".", "size", ")", ":", "xi", "=", "xpx", "[", "ii", "]", "yi", "=", "ypx", "[", "ii", "]", "# filter for overlapping events", "if", "valid", "(", "xi", ",", "yi", ")", "and", "toproc", "[", "int", "(", "xi", "-", "1", ")", ",", "int", "(", "yi", "-", "1", ")", "]", ":", "toproc", "[", "int", "(", "xi", "-", "1", ")", ",", "int", "(", "yi", "-", "1", ")", "]", "=", "False", "# include event", "keep", "[", "ii", "]", "=", "True", "# 2. Make sure that we reach `samples` by adding or", "# removing events.", "diff", "=", "np", ".", "sum", "(", "keep", ")", "-", "samples", "if", "diff", ">", "0", ":", "# Too many samples", "rem_indices", "=", "np", ".", "where", "(", "keep", ")", "[", "0", "]", "np", ".", "random", ".", "set_state", "(", "rs", ")", "rem", "=", "np", ".", "random", ".", "choice", "(", "rem_indices", ",", "size", "=", "diff", ",", "replace", "=", "False", ")", "keep", "[", "rem", "]", "=", "False", "elif", "diff", "<", "0", ":", "# Not enough samples", "add_indices", "=", "np", ".", "where", "(", "~", "keep", ")", "[", "0", "]", "np", ".", "random", ".", "set_state", "(", "rs", ")", "add", "=", "np", ".", "random", ".", "choice", "(", "add_indices", ",", "size", "=", "abs", "(", "diff", ")", ",", "replace", "=", "False", ")", "keep", "[", "add", "]", "=", "True", "assert", "np", ".", "sum", "(", "keep", ")", "==", "samples", ",", "\"sanity check\"", "asd", "=", "a", "[", "keep", "]", "bsd", "=", "b", "[", "keep", "]", "assert", "np", ".", "allclose", "(", "a", "[", "keep", "]", ",", "asd", ",", "equal_nan", "=", "True", ")", ",", "\"sanity check\"", "assert", "np", ".", "allclose", "(", "b", "[", "keep", "]", ",", "bsd", ",", "equal_nan", "=", "True", ")", ",", "\"sanity check\"", "else", ":", "keep", "=", "np", ".", "ones_like", "(", "a", ",", "dtype", "=", "bool", ")", "asd", "=", "a", "bsd", "=", "b", "if", "ret_idx", ":", "return", "asd", ",", "bsd", ",", "keep", "else", ":", "return", "asd", ",", "bsd" ]

[ "Content", "-", "based", "downsampling", "for", "faster", "visualization" ]

[ "def", "fft_freqs", "(", "n_fft", ",", "fs", ")", ":", "return", "np", ".", "arange", "(", "0", ",", "(", "n_fft", "//", "2", "+", "1", ")", ")", "/", "float", "(", "n_fft", ")", "*", "float", "(", "fs", ")" ]

[ "Return", "frequencies", "for", "DFT" ]

[ "def", "print_MannWhitneyU", "(", "div_calc", ")", ":", "try", ":", "x", "=", "div_calc", ".", "values", "(", ")", "[", "0", "]", ".", "values", "(", ")", "y", "=", "div_calc", ".", "values", "(", ")", "[", "1", "]", ".", "values", "(", ")", "except", ":", "return", "\"Error setting up input arrays for Mann-Whitney U Test. Skipping \"", "\"significance testing.\"", "T", ",", "p", "=", "stats", ".", "mannwhitneyu", "(", "x", ",", "y", ")", "print", "\"\\nMann-Whitney U test statistic:\"", ",", "T", "print", "\"Two-tailed p-value: {}\"", ".", "format", "(", "2", "*", "p", ")" ]

[ "Compute", "the", "Mann", "-", "Whitney", "U", "test", "for", "unequal", "group", "sample", "sizes", "." ]

[ "def", "acquire_discharge", "(", "self", ",", "cav", ",", "payload", ")", ":", "resp", "=", "self", ".", "_acquire_discharge_with_token", "(", "cav", ",", "payload", ",", "None", ")", "# TODO Fabrice what is the other http response possible ??", "if", "resp", ".", "status_code", "==", "200", ":", "return", "bakery", ".", "Macaroon", ".", "from_dict", "(", "resp", ".", "json", "(", ")", ".", "get", "(", "'Macaroon'", ")", ")", "cause", "=", "Error", ".", "from_dict", "(", "resp", ".", "json", "(", ")", ")", "if", "cause", ".", "code", "!=", "ERR_INTERACTION_REQUIRED", ":", "raise", "DischargeError", "(", "cause", ".", "message", ")", "if", "cause", ".", "info", "is", "None", ":", "raise", "DischargeError", "(", "'interaction-required response with no info: {}'", ".", "format", "(", "resp", ".", "json", "(", ")", ")", ")", "loc", "=", "cav", ".", "location", "if", "not", "loc", ".", "endswith", "(", "'/'", ")", ":", "loc", "=", "loc", "+", "'/'", "token", ",", "m", "=", "self", ".", "_interact", "(", "loc", ",", "cause", ",", "payload", ")", "if", "m", "is", "not", "None", ":", "# We've acquired the macaroon directly via legacy interaction.", "return", "m", "# Try to acquire the discharge again, but this time with", "# the token acquired by the interaction method.", "resp", "=", "self", ".", "_acquire_discharge_with_token", "(", "cav", ",", "payload", ",", "token", ")", "if", "resp", ".", "status_code", "==", "200", ":", "return", "bakery", ".", "Macaroon", ".", "from_dict", "(", "resp", ".", "json", "(", ")", ".", "get", "(", "'Macaroon'", ")", ")", "else", ":", "raise", "DischargeError", "(", "'discharge failed with code {}'", ".", "format", "(", "resp", ".", "status_code", ")", ")" ]

[ "Request", "a", "discharge", "macaroon", "from", "the", "caveat", "location", "as", "an", "HTTP", "URL", "." ]

[ "def", "init_i18n", "(", "loc", "=", "None", ")", ":", "if", "'LOCPATH'", "in", "os", ".", "environ", ":", "locdir", "=", "os", ".", "environ", "[", "'LOCPATH'", "]", "else", ":", "locdir", "=", "os", ".", "path", ".", "join", "(", "get_install_data", "(", ")", ",", "'share'", ",", "'locale'", ")", "i18n", ".", "init", "(", "configdata", ".", "name", ".", "lower", "(", ")", ",", "locdir", ",", "loc", "=", "loc", ")", "# install translated log level names", "import", "logging", "logging", ".", "addLevelName", "(", "logging", ".", "CRITICAL", ",", "_", "(", "'CRITICAL'", ")", ")", "logging", ".", "addLevelName", "(", "logging", ".", "ERROR", ",", "_", "(", "'ERROR'", ")", ")", "logging", ".", "addLevelName", "(", "logging", ".", "WARN", ",", "_", "(", "'WARN'", ")", ")", "logging", ".", "addLevelName", "(", "logging", ".", "WARNING", ",", "_", "(", "'WARNING'", ")", ")", "logging", ".", "addLevelName", "(", "logging", ".", "INFO", ",", "_", "(", "'INFO'", ")", ")", "logging", ".", "addLevelName", "(", "logging", ".", "DEBUG", ",", "_", "(", "'DEBUG'", ")", ")", "logging", ".", "addLevelName", "(", "logging", ".", "NOTSET", ",", "_", "(", "'NOTSET'", ")", ")" ]

[ "Initialize", "i18n", "with", "the", "configured", "locale", "dir", ".", "The", "environment", "variable", "LOCPATH", "can", "also", "specify", "a", "locale", "dir", "." ]

[ "def", "get_authority_key_identifier", "(", "self", ")", ":", "try", ":", "ski", "=", "self", ".", "x509", ".", "extensions", ".", "get_extension_for_class", "(", "x509", ".", "SubjectKeyIdentifier", ")", "except", "x509", ".", "ExtensionNotFound", ":", "return", "x509", ".", "AuthorityKeyIdentifier", ".", "from_issuer_public_key", "(", "self", ".", "x509", ".", "public_key", "(", ")", ")", "else", ":", "return", "x509", ".", "AuthorityKeyIdentifier", ".", "from_issuer_subject_key_identifier", "(", "ski", ")" ]

[ "Return", "the", "AuthorityKeyIdentifier", "extension", "used", "in", "certificates", "signed", "by", "this", "CA", "." ]

[ "def", "confirm", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "try", ":", "return", "click", ".", "confirm", "(", "*", "args", ",", "*", "*", "kwargs", ")", "except", "click", ".", "Abort", ":", "return", "False" ]

[ "Prompt", "for", "confirmation", "(", "yes", "/", "no", ")", "and", "handle", "any", "abort", "exceptions", "." ]

[ "def", "express_endpoint_for_token", "(", "token", ",", "commit", "=", "False", ")", ":", "pp_params", "=", "dict", "(", "token", "=", "token", ")", "if", "commit", ":", "pp_params", "[", "'useraction'", "]", "=", "'commit'", "return", "express_endpoint", "(", ")", "%", "urlencode", "(", "pp_params", ")" ]

[ "Returns", "the", "PayPal", "Express", "Checkout", "endpoint", "for", "a", "token", ".", "Pass", "commit", "=", "True", "if", "you", "will", "not", "prompt", "for", "confirmation", "when", "the", "user", "returns", "to", "your", "site", "." ]

[ "def", "save_states", "(", "self", ",", "fname", ")", ":", "assert", "self", ".", "_optimizer", "is", "not", "None", "if", "not", "self", ".", "_kv_initialized", ":", "self", ".", "_init_kvstore", "(", ")", "if", "self", ".", "_params_to_init", ":", "self", ".", "_init_params", "(", ")", "if", "self", ".", "_update_on_kvstore", ":", "assert", "not", "self", ".", "_params_to_init", ",", "\"Cannot save trainer states when some \"", "\"parameters are not yet initialized in kvstore.\"", "self", ".", "_kvstore", ".", "save_optimizer_states", "(", "fname", ",", "dump_optimizer", "=", "True", ")", "else", ":", "with", "open", "(", "fname", ",", "'wb'", ")", "as", "fout", ":", "fout", ".", "write", "(", "self", ".", "_updaters", "[", "0", "]", ".", "get_states", "(", "dump_optimizer", "=", "True", ")", ")" ]

[ "Saves", "trainer", "states", "(", "e", ".", "g", ".", "optimizer", "momentum", ")", "to", "a", "file", "." ]

[ "def", "post", "(", "self", ",", "request", ",", "*", "args", ",", "*", "*", "kwargs", ")", ":", "# Ensure that we check for the 'data' key in the request object before", "# attempting to reference it", "if", "\"data\"", "in", "request", ".", "data", ":", "# This is a workaround for JSONField not liking blank/null refs", "if", "\"metadata\"", "not", "in", "request", ".", "data", "[", "\"data\"", "]", ":", "request", ".", "data", "[", "\"data\"", "]", "[", "\"metadata\"", "]", "=", "{", "}", "if", "\"initial_sequence_number\"", "not", "in", "request", ".", "data", "[", "\"data\"", "]", ":", "request", ".", "data", "[", "\"data\"", "]", "[", "\"initial_sequence_number\"", "]", "=", "request", ".", "data", "[", "\"data\"", "]", ".", "get", "(", "\"next_sequence_number\"", ")", "subscription", "=", "SubscriptionSerializer", "(", "data", "=", "request", ".", "data", "[", "\"data\"", "]", ")", "if", "subscription", ".", "is_valid", "(", ")", ":", "subscription", ".", "save", "(", ")", "# Return", "status", "=", "201", "accepted", "=", "{", "\"accepted\"", ":", "True", "}", "return", "Response", "(", "accepted", ",", "status", "=", "status", ")", "else", ":", "status", "=", "400", "return", "Response", "(", "subscription", ".", "errors", ",", "status", "=", "status", ")", "else", ":", "status", "=", "400", "message", "=", "{", "\"data\"", ":", "[", "\"This field is required.\"", "]", "}", "return", "Response", "(", "message", ",", "status", "=", "status", ")" ]

[ "Validates", "subscription", "data", "before", "creating", "Subscription", "message" ]

[ "def", "chart", "(", "symbols", "=", "(", "\"AAPL\"", ",", "\"GLD\"", ",", "\"GOOG\"", ",", "\"$SPX\"", ",", "\"XOM\"", ",", "\"msft\"", ")", ",", "start", "=", "datetime", ".", "datetime", "(", "2008", ",", "1", ",", "1", ")", ",", "end", "=", "datetime", ".", "datetime", "(", "2009", ",", "12", ",", "31", ")", ",", "# data stops at 2013/1/1", "normalize", "=", "True", ",", ")", ":", "start", "=", "util", ".", "normalize_date", "(", "start", "or", "datetime", ".", "date", "(", "2008", ",", "1", ",", "1", ")", ")", "end", "=", "util", ".", "normalize_date", "(", "end", "or", "datetime", ".", "date", "(", "2009", ",", "12", ",", "31", ")", ")", "symbols", "=", "[", "s", ".", "upper", "(", ")", "for", "s", "in", "symbols", "]", "timeofday", "=", "datetime", ".", "timedelta", "(", "hours", "=", "16", ")", "timestamps", "=", "du", ".", "getNYSEdays", "(", "start", ",", "end", ",", "timeofday", ")", "ls_keys", "=", "[", "'open'", ",", "'high'", ",", "'low'", ",", "'close'", ",", "'volume'", ",", "'actual_close'", "]", "ldf_data", "=", "da", ".", "get_data", "(", "timestamps", ",", "symbols", ",", "ls_keys", ")", "d_data", "=", "dict", "(", "zip", "(", "ls_keys", ",", "ldf_data", ")", ")", "na_price", "=", "d_data", "[", "'close'", "]", ".", "values", "if", "normalize", ":", "na_price", "/=", "na_price", "[", "0", ",", ":", "]", "plt", ".", "clf", "(", ")", "plt", ".", "plot", "(", "timestamps", ",", "na_price", ")", "plt", ".", "legend", "(", "symbols", ")", "plt", ".", "ylabel", "(", "'Adjusted Close'", ")", "plt", ".", "xlabel", "(", "'Date'", ")", "plt", ".", "savefig", "(", "'chart.pdf'", ",", "format", "=", "'pdf'", ")", "plt", ".", "grid", "(", "True", ")", "plt", ".", "show", "(", ")", "return", "na_price" ]

[ "Display", "a", "graph", "of", "the", "price", "history", "for", "the", "list", "of", "ticker", "symbols", "provided" ]

[ "def", "_build_full_partition", "(", "optional_parts", ",", "sequence_var_partition", ":", "Sequence", "[", "int", "]", ",", "subjects", ":", "Sequence", "[", "Expression", "]", ",", "operation", ":", "Operation", ")", "->", "List", "[", "Sequence", "[", "Expression", "]", "]", ":", "i", "=", "0", "var_index", "=", "0", "opt_index", "=", "0", "result", "=", "[", "]", "for", "operand", "in", "op_iter", "(", "operation", ")", ":", "wrap_associative", "=", "False", "if", "isinstance", "(", "operand", ",", "Wildcard", ")", ":", "count", "=", "operand", ".", "min_count", "if", "operand", ".", "optional", "is", "None", "else", "0", "if", "not", "operand", ".", "fixed_size", "or", "isinstance", "(", "operation", ",", "AssociativeOperation", ")", ":", "count", "+=", "sequence_var_partition", "[", "var_index", "]", "var_index", "+=", "1", "wrap_associative", "=", "operand", ".", "fixed_size", "and", "operand", ".", "min_count", "elif", "operand", ".", "optional", "is", "not", "None", ":", "count", "=", "optional_parts", "[", "opt_index", "]", "opt_index", "+=", "1", "else", ":", "count", "=", "1", "operand_expressions", "=", "list", "(", "op_iter", "(", "subjects", ")", ")", "[", "i", ":", "i", "+", "count", "]", "i", "+=", "count", "if", "wrap_associative", "and", "len", "(", "operand_expressions", ")", ">", "wrap_associative", ":", "fixed", "=", "wrap_associative", "-", "1", "operand_expressions", "=", "tuple", "(", "operand_expressions", "[", ":", "fixed", "]", ")", "+", "(", "create_operation_expression", "(", "operation", ",", "operand_expressions", "[", "fixed", ":", "]", ")", ",", ")", "result", ".", "append", "(", "operand_expressions", ")", "return", "result" ]

[ "Distribute", "subject", "operands", "among", "pattern", "operands", "." ]

[ "def", "_scroll_without_linewrapping", "(", "self", ",", "ui_content", ",", "width", ",", "height", ",", "cli", ")", ":", "cursor_position", "=", "ui_content", ".", "cursor_position", "or", "Point", "(", "0", ",", "0", ")", "# Without line wrapping, we will never have to scroll vertically inside", "# a single line.", "self", ".", "vertical_scroll_2", "=", "0", "if", "ui_content", ".", "line_count", "==", "0", ":", "self", ".", "vertical_scroll", "=", "0", "self", ".", "horizontal_scroll", "=", "0", "return", "else", ":", "current_line_text", "=", "token_list_to_text", "(", "ui_content", ".", "get_line", "(", "cursor_position", ".", "y", ")", ")", "def", "do_scroll", "(", "current_scroll", ",", "scroll_offset_start", ",", "scroll_offset_end", ",", "cursor_pos", ",", "window_size", ",", "content_size", ")", ":", "\" Scrolling algorithm. Used for both horizontal and vertical scrolling. \"", "# Calculate the scroll offset to apply.", "# This can obviously never be more than have the screen size. Also, when the", "# cursor appears at the top or bottom, we don't apply the offset.", "scroll_offset_start", "=", "int", "(", "min", "(", "scroll_offset_start", ",", "window_size", "/", "2", ",", "cursor_pos", ")", ")", "scroll_offset_end", "=", "int", "(", "min", "(", "scroll_offset_end", ",", "window_size", "/", "2", ",", "content_size", "-", "1", "-", "cursor_pos", ")", ")", "# Prevent negative scroll offsets.", "if", "current_scroll", "<", "0", ":", "current_scroll", "=", "0", "# Scroll back if we scrolled to much and there's still space to show more of the document.", "if", "(", "not", "self", ".", "allow_scroll_beyond_bottom", "(", "cli", ")", "and", "current_scroll", ">", "content_size", "-", "window_size", ")", ":", "current_scroll", "=", "max", "(", "0", ",", "content_size", "-", "window_size", ")", "# Scroll up if cursor is before visible part.", "if", "current_scroll", ">", "cursor_pos", "-", "scroll_offset_start", ":", "current_scroll", "=", "max", "(", "0", ",", "cursor_pos", "-", "scroll_offset_start", ")", "# Scroll down if cursor is after visible part.", "if", "current_scroll", "<", "(", "cursor_pos", "+", "1", ")", "-", "window_size", "+", "scroll_offset_end", ":", "current_scroll", "=", "(", "cursor_pos", "+", "1", ")", "-", "window_size", "+", "scroll_offset_end", "return", "current_scroll", "# When a preferred scroll is given, take that first into account.", "if", "self", ".", "get_vertical_scroll", ":", "self", ".", "vertical_scroll", "=", "self", ".", "get_vertical_scroll", "(", "self", ")", "assert", "isinstance", "(", "self", ".", "vertical_scroll", ",", "int", ")", "if", "self", ".", "get_horizontal_scroll", ":", "self", ".", "horizontal_scroll", "=", "self", ".", "get_horizontal_scroll", "(", "self", ")", "assert", "isinstance", "(", "self", ".", "horizontal_scroll", ",", "int", ")", "# Update horizontal/vertical scroll to make sure that the cursor", "# remains visible.", "offsets", "=", "self", ".", "scroll_offsets", "self", ".", "vertical_scroll", "=", "do_scroll", "(", "current_scroll", "=", "self", ".", "vertical_scroll", ",", "scroll_offset_start", "=", "offsets", ".", "top", ",", "scroll_offset_end", "=", "offsets", ".", "bottom", ",", "cursor_pos", "=", "ui_content", ".", "cursor_position", ".", "y", ",", "window_size", "=", "height", ",", "content_size", "=", "ui_content", ".", "line_count", ")", "self", ".", "horizontal_scroll", "=", "do_scroll", "(", "current_scroll", "=", "self", ".", "horizontal_scroll", ",", "scroll_offset_start", "=", "offsets", ".", "left", ",", "scroll_offset_end", "=", "offsets", ".", "right", ",", "cursor_pos", "=", "get_cwidth", "(", "current_line_text", "[", ":", "ui_content", ".", "cursor_position", ".", "x", "]", ")", ",", "window_size", "=", "width", ",", "# We can only analyse the current line. Calculating the width off", "# all the lines is too expensive.", "content_size", "=", "max", "(", "get_cwidth", "(", "current_line_text", ")", ",", "self", ".", "horizontal_scroll", "+", "width", ")", ")" ]

[ "Scroll", "to", "make", "sure", "the", "cursor", "position", "is", "visible", "and", "that", "we", "maintain", "the", "requested", "scroll", "offset", "." ]

[ "def", "get", "(", "self", ")", ":", "return", "TaskQueueStatisticsContext", "(", "self", ".", "_version", ",", "workspace_sid", "=", "self", ".", "_solution", "[", "'workspace_sid'", "]", ",", "task_queue_sid", "=", "self", ".", "_solution", "[", "'task_queue_sid'", "]", ",", ")" ]

[ "Constructs", "a", "TaskQueueStatisticsContext" ]

[ "def", "run", "(", "self", ",", "graminit_h", ",", "graminit_c", ")", ":", "self", ".", "parse_graminit_h", "(", "graminit_h", ")", "self", ".", "parse_graminit_c", "(", "graminit_c", ")", "self", ".", "finish_off", "(", ")" ]

[ "Load", "the", "grammar", "tables", "from", "the", "text", "files", "written", "by", "pgen", "." ]

[ "def", "crop_image", "(", "image", ",", "label_image", "=", "None", ",", "label", "=", "1", ")", ":", "inpixeltype", "=", "image", ".", "pixeltype", "ndim", "=", "image", ".", "dimension", "if", "image", ".", "pixeltype", "!=", "'float'", ":", "image", "=", "image", ".", "clone", "(", "'float'", ")", "if", "label_image", "is", "None", ":", "label_image", "=", "get_mask", "(", "image", ")", "if", "label_image", ".", "pixeltype", "!=", "'float'", ":", "label_image", "=", "label_image", ".", "clone", "(", "'float'", ")", "libfn", "=", "utils", ".", "get_lib_fn", "(", "'cropImageF%i'", "%", "ndim", ")", "itkimage", "=", "libfn", "(", "image", ".", "pointer", ",", "label_image", ".", "pointer", ",", "label", ",", "0", ",", "[", "]", ",", "[", "]", ")", "return", "iio", ".", "ANTsImage", "(", "pixeltype", "=", "'float'", ",", "dimension", "=", "ndim", ",", "components", "=", "image", ".", "components", ",", "pointer", "=", "itkimage", ")", ".", "clone", "(", "inpixeltype", ")" ]

[ "Use", "a", "label", "image", "to", "crop", "a", "smaller", "ANTsImage", "from", "within", "a", "larger", "ANTsImage" ]

[ "def", "extract_paths", "(", "self", ",", "paths", ",", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "self", ".", "provider", ".", "extract_paths", "(", "paths", ",", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "Thin", "method", "that", "just", "uses", "the", "provider" ]

[ "def", "create_dicts", "(", "data", ")", ":", "chars", "=", "set", "(", ")", "for", "sample", "in", "data", ":", "chars", ".", "update", "(", "set", "(", "sample", ")", ")", "char_indices", "=", "dict", "(", "(", "c", ",", "i", ")", "for", "i", ",", "c", "in", "enumerate", "(", "chars", ")", ")", "indices_char", "=", "dict", "(", "(", "i", ",", "c", ")", "for", "i", ",", "c", "in", "enumerate", "(", "chars", ")", ")", "return", "char_indices", ",", "indices_char" ]

[ "Modified", "from", "Keras", "LSTM", "example" ]

[ "def", "position_permutation", "(", "obs_stat", ",", "context_counts", ",", "context_to_mut", ",", "seq_context", ",", "gene_seq", ",", "gene_vest", "=", "None", ",", "num_permutations", "=", "10000", ",", "stop_criteria", "=", "100", ",", "pseudo_count", "=", "0", ",", "max_batch", "=", "25000", ")", ":", "# get contexts and somatic base", "mycontexts", "=", "context_counts", ".", "index", ".", "tolist", "(", ")", "somatic_base", "=", "[", "base", "for", "one_context", "in", "mycontexts", "for", "base", "in", "context_to_mut", "[", "one_context", "]", "]", "# calculate the # of batches for simulations", "max_batch", "=", "min", "(", "num_permutations", ",", "max_batch", ")", "num_batches", "=", "num_permutations", "//", "max_batch", "remainder", "=", "num_permutations", "%", "max_batch", "batch_sizes", "=", "[", "max_batch", "]", "*", "num_batches", "if", "remainder", ":", "batch_sizes", "+=", "[", "remainder", "]", "obs_recur", ",", "obs_ent", ",", "obs_delta_ent", ",", "obs_vest", "=", "obs_stat", "num_sim", "=", "0", "# number of simulations", "null_num_recur_ct", ",", "null_entropy_ct", ",", "null_delta_entropy_ct", ",", "null_vest_ct", "=", "0", ",", "0", ",", "0", ",", "0", "for", "j", ",", "batch_size", "in", "enumerate", "(", "batch_sizes", ")", ":", "# stop iterations if reached sufficient precision", "if", "null_vest_ct", ">=", "stop_criteria", "and", "null_entropy_ct", ">=", "stop_criteria", ":", "break", "# get random positions determined by sequence context", "tmp_contxt_pos", "=", "seq_context", ".", "random_pos", "(", "context_counts", ".", "iteritems", "(", ")", ",", "batch_size", ")", "tmp_mut_pos", "=", "np", ".", "hstack", "(", "pos_array", "for", "base", ",", "pos_array", "in", "tmp_contxt_pos", ")", "# calculate position-based statistics as a result of random positions", "for", "i", ",", "row", "in", "enumerate", "(", "tmp_mut_pos", ")", ":", "# get info about mutations", "tmp_mut_info", "=", "mc", ".", "get_aa_mut_info", "(", "row", ",", "somatic_base", ",", "gene_seq", ")", "# calculate position info", "tmp_recur_ct", ",", "tmp_entropy", ",", "tmp_delta_entropy", ",", "_", "=", "cutils", ".", "calc_pos_info", "(", "tmp_mut_info", "[", "'Codon Pos'", "]", ",", "tmp_mut_info", "[", "'Reference AA'", "]", ",", "tmp_mut_info", "[", "'Somatic AA'", "]", ",", "pseudo_count", "=", "pseudo_count", ",", "is_obs", "=", "0", ")", "# get vest scores", "if", "gene_vest", ":", "tmp_vest", "=", "scores", ".", "compute_vest_stat", "(", "gene_vest", ",", "tmp_mut_info", "[", "'Reference AA'", "]", ",", "tmp_mut_info", "[", "'Somatic AA'", "]", ",", "tmp_mut_info", "[", "'Codon Pos'", "]", ")", "else", ":", "tmp_vest", "=", "0.0", "# update empirical null distribution counts", "if", "tmp_entropy", "-", "utils", ".", "epsilon", "<=", "obs_ent", ":", "null_entropy_ct", "+=", "1", "if", "tmp_vest", "+", "utils", ".", "epsilon", ">=", "obs_vest", ":", "null_vest_ct", "+=", "1", "# stop iterations if reached sufficient precision", "if", "null_vest_ct", ">=", "stop_criteria", "and", "null_entropy_ct", ">=", "stop_criteria", ":", "break", "# update the number of simulations", "num_sim", "+=", "i", "+", "1", "# calculate p-value from empirical null-distribution", "ent_pval", "=", "float", "(", "null_entropy_ct", ")", "/", "(", "num_sim", ")", "vest_pval", "=", "float", "(", "null_vest_ct", ")", "/", "(", "num_sim", ")", "return", "ent_pval", ",", "vest_pval" ]

[ "Performs", "null", "-", "permutations", "for", "position", "-", "based", "mutation", "statistics", "in", "a", "single", "gene", "." ]

[ "def", "saveProfileAs", "(", "self", ")", ":", "name", ",", "ok", "=", "QInputDialog", ".", "getText", "(", "self", ",", "'Create Profile'", ",", "'Name:'", ")", "if", "(", "not", "name", ")", ":", "return", "manager", "=", "self", ".", "parent", "(", ")", "prof", "=", "manager", ".", "viewWidget", "(", ")", ".", "saveProfile", "(", ")", "prof", ".", "setName", "(", "nativestring", "(", "name", ")", ")", "self", ".", "parent", "(", ")", ".", "addProfile", "(", "prof", ")" ]

[ "Saves", "the", "current", "profile", "as", "a", "new", "profile", "to", "the", "manager", "." ]

[ "def", "convert_csv_annotations_to_cropobject", "(", "annotations_path", ":", "str", ",", "image_path", ":", "str", ")", "->", "List", "[", "CropObject", "]", ":", "annotations", "=", "pd", ".", "read_csv", "(", "annotations_path", ")", "image", "=", "Image", ".", "open", "(", "image_path", ")", "# type: Image.Image", "crop_objects", "=", "[", "]", "node_id", "=", "0", "for", "index", ",", "annotation", "in", "annotations", ".", "iterrows", "(", ")", ":", "# Annotation example:", "# image_name,top,left,bottom,right,class_name,confidence", "# CVC-MUSCIMA_W-01_N-10_D-ideal_1.png,138.93,2286.36,185.20,2316.52,8th_flag,1.00", "image_name", "=", "annotation", "[", "\"image_name\"", "]", "class_name", "=", "annotation", "[", "\"class_name\"", "]", "top", "=", "round", "(", "annotation", "[", "\"top\"", "]", ")", "left", "=", "round", "(", "annotation", "[", "\"left\"", "]", ")", "width", "=", "round", "(", "annotation", "[", "\"right\"", "]", "-", "annotation", "[", "\"left\"", "]", ")", "heigth", "=", "round", "(", "annotation", "[", "\"bottom\"", "]", "-", "annotation", "[", "\"top\"", "]", ")", "crop_object", "=", "CropObject", "(", "node_id", ",", "class_name", ",", "top", ",", "left", ",", "width", ",", "heigth", ")", "crop_object", ".", "set_doc", "(", "image_name", ")", "crop_image", "=", "image", ".", "crop", "(", "(", "left", ",", "top", ",", "crop_object", ".", "right", ",", "crop_object", ".", "bottom", ")", ")", ".", "convert", "(", "\"1\"", ")", "# noinspection PyTypeChecker", "cropped_image_mask", "=", "np", ".", "array", "(", "crop_image", ")", "crop_object", ".", "set_mask", "(", "cropped_image_mask", ")", "crop_objects", ".", "append", "(", "crop_object", ")", "node_id", "+=", "1", "return", "crop_objects" ]

[ "Converts", "a", "normalized", "dataset", "of", "objects", "into", "crop", "-", "objects", ".", ":", "param", "annotations_path", ":", "Path", "to", "the", "csv", "-", "file", "that", "contains", "bounding", "boxes", "in", "the", "following", "format", "for", "a", "single", "image", ":", "image_name", "top", "left", "bottom", "right", "class_name", "confidence", "CVC", "-", "MUSCIMA_W", "-", "01_N", "-", "10_D", "-", "ideal_1", ".", "png", "138", ".", "93", "2286", ".", "36", "185", ".", "20", "2316", ".", "52", "8th_flag", "1", ".", "00", ":", "param", "image_path", ":", "Image", "that", "is", "being", "described", "by", "the", "file", "given", "under", "the", "annotations_path", ":", "return", ":", "A", "list", "of", "CropObjects", "as", "being", "used", "by", "the", "MUSCIMA", "++", "dataset", "including", "the", "binary", "image", "-", "masks" ]

[ "def", "indicator_arrays", "(", "tc_entity_array", ")", ":", "type_dict", "=", "{", "}", "for", "ea", "in", "tc_entity_array", ":", "type_dict", ".", "setdefault", "(", "ea", "[", "'type'", "]", ",", "[", "]", ")", ".", "append", "(", "ea", "[", "'value'", "]", ")", "return", "type_dict" ]

[ "Convert", "TCEntityArray", "to", "Indicator", "Type", "dictionary", "." ]

[ "def", "format_value", "(", "value", ")", ":", "value_id", "=", "id", "(", "value", ")", "if", "value_id", "in", "recursion_breaker", ".", "processed", ":", "return", "u'<recursion>'", "recursion_breaker", ".", "processed", ".", "add", "(", "value_id", ")", "try", ":", "if", "isinstance", "(", "value", ",", "six", ".", "binary_type", ")", ":", "# suppose, all byte strings are in unicode", "# don't know if everybody in the world uses anything else?", "return", "u\"'{0}'\"", ".", "format", "(", "value", ".", "decode", "(", "'utf-8'", ")", ")", "elif", "isinstance", "(", "value", ",", "six", ".", "text_type", ")", ":", "return", "u\"u'{0}'\"", ".", "format", "(", "value", ")", "elif", "isinstance", "(", "value", ",", "(", "list", ",", "tuple", ")", ")", ":", "# long lists or lists with multiline items", "# will be shown vertically", "values", "=", "list", "(", "map", "(", "format_value", ",", "value", ")", ")", "result", "=", "serialize_list", "(", "u'['", ",", "values", ",", "delimiter", "=", "u','", ")", "+", "u']'", "return", "force_unicode", "(", "result", ")", "elif", "isinstance", "(", "value", ",", "dict", ")", ":", "items", "=", "six", ".", "iteritems", "(", "value", ")", "# format each key/value pair as a text,", "# calling format_value recursively", "items", "=", "(", "tuple", "(", "map", "(", "format_value", ",", "item", ")", ")", "for", "item", "in", "items", ")", "items", "=", "list", "(", "items", ")", "# sort by keys for readability", "items", ".", "sort", "(", ")", "# for each item value", "items", "=", "[", "serialize_text", "(", "u'{0}: '", ".", "format", "(", "key", ")", ",", "item_value", ")", "for", "key", ",", "item_value", "in", "items", "]", "# and serialize these pieces as a list, enclosing", "# them into a curve brackets", "result", "=", "serialize_list", "(", "u'{'", ",", "items", ",", "delimiter", "=", "u','", ")", "+", "u'}'", "return", "force_unicode", "(", "result", ")", "return", "force_unicode", "(", "repr", "(", "value", ")", ")", "finally", ":", "recursion_breaker", ".", "processed", ".", "remove", "(", "value_id", ")" ]

[ "This", "function", "should", "return", "unicode", "representation", "of", "the", "value" ]

[ "def", "matte", "(", "self", ",", "x", ",", "y", ",", "paint_method", ")", ":", "paint_method", "=", "_convert_paintmethod", "(", "paint_method", ")", "self", ".", "drawer", ".", "append", "(", "pgmagick", ".", "DrawableMatte", "(", "x", ",", "y", ",", "paint_method", ")", ")" ]

[ ":", "param", "paint_method", ":", "point", "or", "replace", "or", "floodfill", "or", "filltoborder", "or", "reset", ":", "type", "paint_method", ":", "str", "or", "pgmagick", ".", "PaintMethod" ]

[ "def", "export_hmaps_csv", "(", "key", ",", "dest", ",", "sitemesh", ",", "array", ",", "comment", ")", ":", "curves", "=", "util", ".", "compose_arrays", "(", "sitemesh", ",", "array", ")", "writers", ".", "write_csv", "(", "dest", ",", "curves", ",", "comment", "=", "comment", ")", "return", "[", "dest", "]" ]

[ "Export", "the", "hazard", "maps", "of", "the", "given", "realization", "into", "CSV", "." ]

[ "def", "loop", "(", "self", ")", ":", "if", "not", "self", ".", "_loop", ":", "self", ".", "_loop", "=", "IOLoop", ".", "current", "(", ")", "return", "self", ".", "_loop", "return", "self", ".", "_loop" ]

[ "Lazy", "event", "loop", "initialization" ]

[ "def", "_resolve_requirements_chain", "(", "requirements", ")", ":", "chain", "=", "[", "]", "if", "isinstance", "(", "requirements", ",", "six", ".", "string_types", ")", ":", "requirements", "=", "[", "requirements", "]", "for", "req_file", "in", "requirements", ":", "chain", ".", "append", "(", "req_file", ")", "chain", ".", "extend", "(", "_resolve_requirements_chain", "(", "_find_req", "(", "req_file", ")", ")", ")", "return", "chain" ]

[ "Return", "an", "array", "of", "requirements", "file", "paths", "that", "can", "be", "used", "to", "complete", "the", "no_chown", "==", "False", "&&", "user", "!", "=", "None", "conundrum" ]

[ "def", "channelize", "(", "gen", ",", "channels", ")", ":", "def", "pick", "(", "g", ",", "channel", ")", ":", "for", "samples", "in", "g", ":", "yield", "samples", "[", "channel", "]", "return", "[", "pick", "(", "gen_copy", ",", "channel", ")", "for", "channel", ",", "gen_copy", "in", "enumerate", "(", "itertools", ".", "tee", "(", "gen", ",", "channels", ")", ")", "]" ]

[ "Break", "multi", "-", "channel", "generator", "into", "one", "sub", "-", "generator", "per", "channel" ]

[ "def", "http_response", "(", "self", ",", "request", ")", ":", "content_types", "=", "request", ".", "content_types", "if", "not", "content_types", "or", "self", ".", "_content_type", "in", "content_types", ":", "response", "=", "request", ".", "response", "response", ".", "content_type", "=", "self", ".", "_content_type", "response", ".", "encoding", "=", "self", ".", "charset", "response", ".", "content", "=", "self", ".", "to_bytes", "(", ")", "return", "response", "else", ":", "raise", "HttpException", "(", "status", "=", "415", ",", "msg", "=", "request", ".", "content_types", ")" ]

[ "Return", "a", ":", "class", ":", ".", "WsgiResponse", "or", "a", ":", "class", ":", "~asyncio", ".", "Future", "." ]

[ "def", "connect_outgoing", "(", "self", ",", "outgoing_task", ",", "outgoing_task_node", ",", "sequence_flow_node", ",", "is_default", ")", ":", "self", ".", "task", ".", "connect_outgoing", "(", "outgoing_task", ",", "sequence_flow_node", ".", "get", "(", "'id'", ")", ",", "sequence_flow_node", ".", "get", "(", "'name'", ",", "None", ")", ",", "self", ".", "parser", ".", "_parse_documentation", "(", "sequence_flow_node", ",", "task_parser", "=", "self", ")", ")" ]

[ "Connects", "this", "task", "to", "the", "indicating", "outgoing", "task", "with", "the", "details", "in", "the", "sequence", "flow", ".", "A", "subclass", "can", "override", "this", "method", "to", "get", "extra", "information", "from", "the", "node", "." ]

[ "def", "_remap", "(", "object", ",", "name", ",", "value", ",", "safe", "=", "True", ")", ":", "if", "os", ".", "getenv", "(", "\"QT_TESTING\"", ")", "is", "not", "None", "and", "safe", ":", "# Cannot alter original binding.", "if", "hasattr", "(", "object", ",", "name", ")", ":", "raise", "AttributeError", "(", "\"Cannot override existing name: \"", "\"%s.%s\"", "%", "(", "object", ".", "__name__", ",", "name", ")", ")", "# Cannot alter classes of functions", "if", "type", "(", "object", ")", ".", "__name__", "!=", "\"module\"", ":", "raise", "AttributeError", "(", "\"%s != 'module': Cannot alter \"", "\"anything but modules\"", "%", "object", ")", "elif", "hasattr", "(", "object", ",", "name", ")", ":", "# Keep track of modifications", "self", ".", "__modified__", ".", "append", "(", "name", ")", "self", ".", "__remapped__", ".", "append", "(", "name", ")", "setattr", "(", "object", ",", "name", ",", "value", ")" ]

[ "Prevent", "accidental", "assignment", "of", "existing", "members" ]

[ "def", "gui", "(", ")", ":", "# #######", "# setup all objects", "# #######", "zones", "=", "[", "ALL", "]", "last_zones", "=", "[", "]", "COLORS", ".", "remove", "(", "WHITE", ")", "screen", "=", "pygame", ".", "display", ".", "set_mode", "(", "SCREEN_SIZE", ",", "DOUBLEBUF", ")", "pygame", ".", "display", ".", "set_caption", "(", "'Bezier simulator'", ")", "pygame", ".", "event", ".", "set_allowed", "(", "[", "QUIT", ",", "KEYDOWN", ",", "MOUSEBUTTONDOWN", "]", ")", "points", "=", "[", "(", "40", ",", "40", ")", ",", "(", "100", ",", "400", ")", ",", "(", "200", ",", "100", ")", ",", "(", "650", ",", "420", ")", "]", "bezier", "=", "Bezier", "(", "(", "0", ",", "0", ")", ",", "SCREEN_SIZE", ",", "points", ",", "ORANGE", ",", "8", ")", "points", "=", "[", "Point", "(", "p", ",", "24", ",", "choice", "(", "COLORS", ")", ")", "for", "p", "in", "points", "]", "clock", "=", "pygame", ".", "time", ".", "Clock", "(", ")", "fps", "=", "FPSIndicator", "(", "clock", ")", "dragging", "=", "None", "render", "=", "True", "while", "True", ":", "# #######", "# Input loop", "# #######", "mouse", "=", "pygame", ".", "mouse", ".", "get_pos", "(", ")", "for", "e", "in", "pygame", ".", "event", ".", "get", "(", ")", ":", "if", "e", ".", "type", "==", "QUIT", ":", "return", "0", "elif", "e", ".", "type", "==", "KEYDOWN", ":", "if", "e", ".", "key", "==", "K_ESCAPE", ":", "return", "0", "if", "e", ".", "key", "==", "K_F4", "and", "e", ".", "mod", "&", "KMOD_ALT", ":", "return", "0", "elif", "e", ".", "type", "==", "MOUSEBUTTONDOWN", ":", "if", "e", ".", "button", "==", "1", ":", "dragging", "=", "not", "dragging", "if", "e", ".", "button", "==", "3", ":", "points", ".", "append", "(", "Point", "(", "mouse", ",", "24", ",", "choice", "(", "COLORS", ")", ")", ")", "bezier", ".", "points", ".", "append", "(", "V2", "(", "mouse", ")", ")", "render", "=", "True", "if", "dragging", ":", "mdist", "=", "10000", "the_p", "=", "None", "for", "i", ",", "p", "in", "enumerate", "(", "points", ")", ":", "if", "p", ".", "dist_to", "(", "mouse", ")", "<", "mdist", ":", "mdist", "=", "p", ".", "dist_to", "(", "mouse", ")", "the_p", "=", "i", "render", "=", "points", "[", "the_p", "]", ".", "pos", "!=", "mouse", "points", "[", "the_p", "]", ".", "pos", "=", "mouse", "bezier", ".", "points", "[", "the_p", "]", "=", "V2", "(", "mouse", ")", "# #######", "# Draw all", "# #######", "if", "render", ":", "render", "=", "False", "screen", ".", "fill", "(", "WHITE", ")", "bezier", ".", "render", "(", "screen", ")", "for", "p", "in", "points", ":", "p", ".", "render", "(", "screen", ")", "zones", ".", "append", "(", "ALL", ")", "_", "=", "fps", ".", "render", "(", "screen", ")", "zones", ".", "append", "(", "_", ")", "pygame", ".", "display", ".", "update", "(", "zones", "+", "last_zones", ")", "last_zones", "=", "zones", "[", ":", "]", "zones", ".", "clear", "(", ")", "clock", ".", "tick", "(", "FPS", ")" ]

[ "Main", "function" ]

[ "def", "Get", "(", "self", ",", "path", ",", "follow_symlink", "=", "True", ")", ":", "key", "=", "self", ".", "_Key", "(", "path", "=", "path", ",", "follow_symlink", "=", "follow_symlink", ")", "try", ":", "return", "self", ".", "_cache", "[", "key", "]", "except", "KeyError", ":", "value", "=", "Stat", ".", "FromPath", "(", "path", ",", "follow_symlink", "=", "follow_symlink", ")", "self", ".", "_cache", "[", "key", "]", "=", "value", "# If we are not following symlinks and the file is a not symlink then", "# the stat result for this file stays the same even if we want to follow", "# symlinks.", "if", "not", "follow_symlink", "and", "not", "value", ".", "IsSymlink", "(", ")", ":", "self", ".", "_cache", "[", "self", ".", "_Key", "(", "path", "=", "path", ",", "follow_symlink", "=", "True", ")", "]", "=", "value", "return", "value" ]

[ "Stats", "given", "file", "or", "returns", "a", "cached", "result", "if", "available", "." ]

[ "def", "to_json", "(", "value", ",", "*", "*", "kwargs", ")", ":", "b64rep", "=", "base64", ".", "b64encode", "(", "value", ".", "read", "(", ")", ")", "value", ".", "seek", "(", "0", ")", "jsonrep", "=", "'{preamble}{b64}'", ".", "format", "(", "preamble", "=", "PNG_PREAMBLE", ",", "b64", "=", "b64rep", ".", "decode", "(", ")", ",", ")", "return", "jsonrep" ]

[ "Convert", "a", "PNG", "Image", "to", "base64", "-", "encoded", "JSON" ]

[ "def", "validate_functions", "(", "ast", ":", "BELAst", ",", "bo", ")", ":", "if", "isinstance", "(", "ast", ",", "Function", ")", ":", "log", ".", "debug", "(", "f\"Validating: {ast.name}, {ast.function_type}, {ast.args}\"", ")", "function_signatures", "=", "bo", ".", "spec", "[", "\"functions\"", "]", "[", "\"signatures\"", "]", "[", "ast", ".", "name", "]", "[", "\"signatures\"", "]", "function_name", "=", "ast", ".", "name", "(", "valid_function", ",", "messages", ")", "=", "check_function_args", "(", "ast", ".", "args", ",", "function_signatures", ",", "function_name", ")", "if", "not", "valid_function", ":", "message", "=", "\", \"", ".", "join", "(", "messages", ")", "bo", ".", "validation_messages", ".", "append", "(", "(", "\"ERROR\"", ",", "\"Invalid BEL Statement function {} - problem with function signatures: {}\"", ".", "format", "(", "ast", ".", "to_string", "(", ")", ",", "message", ")", ",", ")", ")", "bo", ".", "parse_valid", "=", "False", "# Recursively process every NSArg by processing BELAst and Functions", "if", "hasattr", "(", "ast", ",", "\"args\"", ")", ":", "for", "arg", "in", "ast", ".", "args", ":", "validate_functions", "(", "arg", ",", "bo", ")", "return", "bo" ]

[ "Recursively", "validate", "function", "signatures" ]