Datasets:

kejian

/

codesearchnet-python-raw-457k

like 4

[ "def", "time_in_range", "(", "self", ")", ":", "curr", "=", "datetime", ".", "datetime", ".", "now", "(", ")", ".", "time", "(", ")", "if", "self", ".", "start_time", "<=", "self", ".", "end_time", ":", "return", "self", ".", "start_time", "<=", "curr", "<=", "self", ".", "end_time", "else", ":", "return", "self", ".", "start_time", "<=", "curr", "or", "curr", "<=", "self", ".", "end_time" ]

[ "Return", "true", "if", "current", "time", "is", "in", "the", "active", "range" ]

[ "def", "load_config", "(", ")", ":", "filename", "=", "'keyringrc.cfg'", "keyring_cfg", "=", "os", ".", "path", ".", "join", "(", "platform", ".", "config_root", "(", ")", ",", "filename", ")", "if", "not", "os", ".", "path", ".", "exists", "(", "keyring_cfg", ")", ":", "return", "config", "=", "configparser", ".", "RawConfigParser", "(", ")", "config", ".", "read", "(", "keyring_cfg", ")", "_load_keyring_path", "(", "config", ")", "# load the keyring class name, and then load this keyring", "try", ":", "if", "config", ".", "has_section", "(", "\"backend\"", ")", ":", "keyring_name", "=", "config", ".", "get", "(", "\"backend\"", ",", "\"default-keyring\"", ")", ".", "strip", "(", ")", "else", ":", "raise", "configparser", ".", "NoOptionError", "(", "'backend'", ",", "'default-keyring'", ")", "except", "(", "configparser", ".", "NoOptionError", ",", "ImportError", ")", ":", "logger", "=", "logging", ".", "getLogger", "(", "'keyring'", ")", "logger", ".", "warning", "(", "\"Keyring config file contains incorrect values.\\n\"", "+", "\"Config file: %s\"", "%", "keyring_cfg", ")", "return", "return", "load_keyring", "(", "keyring_name", ")" ]

[ "Load", "a", "keyring", "using", "the", "config", "file", "in", "the", "config", "root", "." ]

[ "def", "sayHello", "(", "self", ",", "name", "=", "\"Not given\"", ",", "message", "=", "\"nothing\"", ")", ":", "print", "(", "\"Python.sayHello called by: {0} \"", "\"with message: '{1}'\"", ".", "format", "(", "name", ",", "message", ")", ")", "return", "(", "\"PythonSync says: Howdy {0} \"", "\"that's a nice runtime you got there\"", ".", "format", "(", "name", ")", ")" ]

[ "Synchronous", "implementation", "of", "IHello", ".", "sayHello", "synchronous", "method", ".", "The", "remote", "calling", "thread", "will", "be", "blocked", "until", "this", "is", "executed", "and", "responds", "." ]

[ "def", "set_connection", "(", "host", "=", "None", ",", "database", "=", "None", ",", "user", "=", "None", ",", "password", "=", "None", ")", ":", "c", ".", "CONNECTION", "[", "'HOST'", "]", "=", "host", "c", ".", "CONNECTION", "[", "'DATABASE'", "]", "=", "database", "c", ".", "CONNECTION", "[", "'USER'", "]", "=", "user", "c", ".", "CONNECTION", "[", "'PASSWORD'", "]", "=", "password" ]

[ "Set", "connection", "parameters", ".", "Call", "set_connection", "with", "no", "arguments", "to", "clear", "." ]

[ "def", "__build_author_name_expr", "(", "author_name", ",", "author_email_address", ")", ":", "assert", "author_name", "or", "author_email_address", ",", "'Both arguments MUST NOT be bull'", "# Use the specified name of the author or the username of his email", "# address.", "author_name_expr", "=", "author_name", "or", "author_email_address", "[", ":", "author_email_address", ".", "find", "(", "'@'", ")", "]", "# Escape the name of the author if it contains a space character.", "if", "' '", "in", "author_name_expr", ":", "author_name_expr", "=", "'\"%s\"'", "%", "author_name_expr", "# Complete the name of the author with his email address when specified.", "if", "author_email_address", ":", "author_name_expr", "=", "'%s <%s>'", "%", "(", "author_name_expr", ",", "author_email_address", ")", "return", "author_name_expr" ]

[ "Build", "the", "name", "of", "the", "author", "of", "a", "message", "as", "described", "in", "the", "Internet", "Message", "Format", "specification", ":", "https", ":", "//", "tools", ".", "ietf", ".", "org", "/", "html", "/", "rfc5322#section", "-", "3", ".", "6", ".", "2" ]

[ "def", "zip_entry_rollup", "(", "zipfile", ")", ":", "files", "=", "dirs", "=", "0", "total_c", "=", "total_u", "=", "0", "for", "i", "in", "zipfile", ".", "infolist", "(", ")", ":", "if", "i", ".", "filename", "[", "-", "1", "]", "==", "'/'", ":", "# I wonder if there's a better detection method than this", "dirs", "+=", "1", "else", ":", "files", "+=", "1", "total_c", "+=", "i", ".", "compress_size", "total_u", "+=", "i", ".", "file_size", "return", "files", ",", "dirs", ",", "total_c", ",", "total_u" ]

[ "returns", "a", "tuple", "of", "(", "files", "dirs", "size_uncompressed", "size_compressed", ")", ".", "files", "+", "dirs", "will", "equal", "len", "(", "zipfile", ".", "infolist", ")" ]

[ "def", "_get_reference", "(", "self", ")", ":", "super", "(", ")", ".", "_get_reference", "(", ")", "self", ".", "cubeA_body_id", "=", "self", ".", "sim", ".", "model", ".", "body_name2id", "(", "\"cubeA\"", ")", "self", ".", "cubeB_body_id", "=", "self", ".", "sim", ".", "model", ".", "body_name2id", "(", "\"cubeB\"", ")", "self", ".", "l_finger_geom_ids", "=", "[", "self", ".", "sim", ".", "model", ".", "geom_name2id", "(", "x", ")", "for", "x", "in", "self", ".", "gripper", ".", "left_finger_geoms", "]", "self", ".", "r_finger_geom_ids", "=", "[", "self", ".", "sim", ".", "model", ".", "geom_name2id", "(", "x", ")", "for", "x", "in", "self", ".", "gripper", ".", "right_finger_geoms", "]", "self", ".", "cubeA_geom_id", "=", "self", ".", "sim", ".", "model", ".", "geom_name2id", "(", "\"cubeA\"", ")", "self", ".", "cubeB_geom_id", "=", "self", ".", "sim", ".", "model", ".", "geom_name2id", "(", "\"cubeB\"", ")" ]

[ "Sets", "up", "references", "to", "important", "components", ".", "A", "reference", "is", "typically", "an", "index", "or", "a", "list", "of", "indices", "that", "point", "to", "the", "corresponding", "elements", "in", "a", "flatten", "array", "which", "is", "how", "MuJoCo", "stores", "physical", "simulation", "data", "." ]

[ "def", "create_app", "(", "config", "=", "'udata.settings.Defaults'", ",", "override", "=", "None", ",", "init_logging", "=", "init_logging", ")", ":", "app", "=", "UDataApp", "(", "APP_NAME", ")", "app", ".", "config", ".", "from_object", "(", "config", ")", "settings", "=", "os", ".", "environ", ".", "get", "(", "'UDATA_SETTINGS'", ",", "join", "(", "os", ".", "getcwd", "(", ")", ",", "'udata.cfg'", ")", ")", "if", "exists", "(", "settings", ")", ":", "app", ".", "settings_file", "=", "settings", "# Keep track of loaded settings for diagnostic", "app", ".", "config", ".", "from_pyfile", "(", "settings", ")", "if", "override", ":", "app", ".", "config", ".", "from_object", "(", "override", ")", "# Loads defaults from plugins", "for", "pkg", "in", "entrypoints", ".", "get_roots", "(", "app", ")", ":", "if", "pkg", "==", "'udata'", ":", "continue", "# Defaults are already loaded", "module", "=", "'{}.settings'", ".", "format", "(", "pkg", ")", "if", "pkgutil", ".", "find_loader", "(", "module", ")", ":", "settings", "=", "pkgutil", ".", "get_loader", "(", "module", ")", "for", "key", ",", "default", "in", "settings", ".", "__dict__", ".", "items", "(", ")", ":", "app", ".", "config", ".", "setdefault", "(", "key", ",", "default", ")", "app", ".", "json_encoder", "=", "UDataJsonEncoder", "app", ".", "debug", "=", "app", ".", "config", "[", "'DEBUG'", "]", "and", "not", "app", ".", "config", "[", "'TESTING'", "]", "app", ".", "wsgi_app", "=", "ProxyFix", "(", "app", ".", "wsgi_app", ")", "init_logging", "(", "app", ")", "register_extensions", "(", "app", ")", "return", "app" ]

[ "Factory", "for", "a", "minimal", "application" ]

[ "def", "validate_data", "(", "self", ")", ":", "warnings", "=", "{", "}", "spec_warnings", ",", "samp_warnings", ",", "site_warnings", ",", "loc_warnings", "=", "{", "}", ",", "{", "}", ",", "{", "}", ",", "{", "}", "if", "self", ".", "specimens", ":", "spec_warnings", "=", "self", ".", "validate_items", "(", "self", ".", "specimens", ",", "'specimen'", ")", "if", "self", ".", "samples", ":", "samp_warnings", "=", "self", ".", "validate_items", "(", "self", ".", "samples", ",", "'sample'", ")", "if", "self", ".", "sites", ":", "site_warnings", "=", "self", ".", "validate_items", "(", "self", ".", "sites", ",", "'site'", ")", "if", "self", ".", "locations", ":", "loc_warnings", "=", "self", ".", "validate_items", "(", "self", ".", "locations", ",", "'location'", ")", "return", "spec_warnings", ",", "samp_warnings", ",", "site_warnings", ",", "loc_warnings" ]

[ "Validate", "specimen", "sample", "site", "and", "location", "data", "." ]

[ "def", "get_locations", "(", ")", ":", "arequest", "=", "requests", ".", "get", "(", "LOCATIONS_URL", ",", "headers", "=", "HEADERS", ")", "status_code", "=", "str", "(", "arequest", ".", "status_code", ")", "if", "status_code", "==", "'401'", ":", "_LOGGER", ".", "error", "(", "\"Token expired.\"", ")", "return", "False", "return", "arequest", ".", "json", "(", ")" ]

[ "Pull", "the", "accounts", "locations", "." ]

[ "def", "guess_labels", "(", "self", ",", "doc", ")", ":", "if", "doc", ".", "nb_pages", "<=", "0", ":", "return", "set", "(", ")", "self", ".", "label_guesser", ".", "total_nb_documents", "=", "len", "(", "self", ".", "_docs_by_id", ".", "keys", "(", ")", ")", "label_names", "=", "self", ".", "label_guesser", ".", "guess", "(", "doc", ")", "labels", "=", "set", "(", ")", "for", "label_name", "in", "label_names", ":", "label", "=", "self", ".", "labels", "[", "label_name", "]", "labels", ".", "add", "(", "label", ")", "return", "labels" ]

[ "return", "a", "prediction", "of", "label", "names" ]

[ "def", "_at_extend", "(", "self", ",", "calculator", ",", "rule", ",", "scope", ",", "block", ")", ":", "from", "scss", ".", "selector", "import", "Selector", "selectors", "=", "calculator", ".", "apply_vars", "(", "block", ".", "argument", ")", "rule", ".", "extends_selectors", ".", "extend", "(", "Selector", ".", "parse_many", "(", "selectors", ")", ")" ]

[ "Implements" ]

[ "def", "wrap", "(", "x", ")", ":", "# Detect the type so we can call the proper serialization routine", "if", "isinstance", "(", "x", ",", "G1Element", ")", ":", "return", "_wrap", "(", "x", ",", "serializeG1", ")", "elif", "isinstance", "(", "x", ",", "G2Element", ")", ":", "return", "_wrap", "(", "x", ",", "serializeG2", ")", "elif", "isinstance", "(", "x", ",", "GtElement", ")", ":", "return", "_wrap", "(", "x", ",", "serializeGt", ")", "elif", "isinstance", "(", "x", ",", "str", ")", ":", "return", "x", "elif", "isinstance", "(", "x", ",", "(", "int", ",", "long", ",", "BigInt", ")", ")", ":", "return", "hex", "(", "long", "(", "x", ")", ")", "# All other items", "else", ":", "raise", "NotImplementedError", "(", "\"Cannot unwrap {}; only types {} supported\"", ".", "format", "(", "type", "(", "x", ")", ",", "[", "G1Element", ",", "G2Element", ",", "GtElement", ",", "int", ",", "long", ",", "BigInt", "]", ")", ")" ]

[ "Wraps", "an", "element", "or", "integer", "type", "by", "serializing", "it", "and", "base64", "encoding", "the", "resulting", "bytes", "." ]

[ "def", "set_event_data", "(", "self", ",", "data", ",", "read_attrs", ")", ":", "if", "self", ".", "handle", ".", "mode", "==", "'r'", ":", "raise", "Exception", "(", "'File is not open for writing.'", ")", "read_number", "=", "read_attrs", "[", "'read_number'", "]", "read_group", "=", "'{}/Reads/Read_{}'", ".", "format", "(", "self", ".", "group_name", ",", "read_number", ")", "read_info", "=", "self", ".", "handle", ".", "status", ".", "read_info", "read_number_map", "=", "self", ".", "handle", ".", "status", ".", "read_number_map", "index", "=", "read_number_map", ".", "get", "(", "read_number", ")", "if", "index", "is", "None", ":", "raise", "Exception", "(", "'Cannot add event detection data for a read that does not exist.'", ")", "info", "=", "read_info", "[", "index", "]", "read_attrs", ".", "update", "(", "{", "'read_id'", ":", "info", ".", "read_id", ",", "'start_time'", ":", "info", ".", "start_time", ",", "'duration'", ":", "info", ".", "duration", ",", "'start_mux'", ":", "info", ".", "start_mux", ",", "'median_before'", ":", "info", ".", "median_before", "}", ")", "attrs", "=", "self", ".", "handle", ".", "get_analysis_attributes", "(", "read_group", ")", "if", "attrs", "is", "None", ":", "self", ".", "handle", ".", "add_analysis_subgroup", "(", "self", ".", "group_name", ",", "'Reads/Read_{}'", ".", "format", "(", "read_number", ")", ",", "attrs", "=", "read_attrs", ")", "self", ".", "handle", ".", "add_analysis_dataset", "(", "read_group", ",", "'Events'", ",", "data", ")", "else", ":", "raise", "Exception", "(", "'Event detection data already exists for this analysis and read.'", ")" ]

[ "Set", "event", "data", "with", "the", "specied", "attributes", ".", ":", "param", "data", ":", "Event", "data", "table", ".", ":", "param", "read_attrs", ":", "Attributes", "to", "put", "on", "the", "read", "group", ".", "This", "must", "include", "the", "read_number", "which", "must", "refer", "to", "a", "read", "present", "in", "the", "object", ".", "The", "attributes", "should", "not", "include", "the", "standard", "read", "attributes", ":" ]

[ "def", "_construct_w", "(", "self", ",", "inputs", ")", ":", "depthwise_weight_shape", "=", "self", ".", "_kernel_shape", "+", "(", "self", ".", "_input_channels", ",", "self", ".", "_channel_multiplier", ")", "pointwise_input_size", "=", "self", ".", "_channel_multiplier", "*", "self", ".", "_input_channels", "pointwise_weight_shape", "=", "(", "1", ",", "1", ",", "pointwise_input_size", ",", "self", ".", "_output_channels", ")", "if", "\"w_dw\"", "not", "in", "self", ".", "_initializers", ":", "fan_in_shape", "=", "depthwise_weight_shape", "[", ":", "2", "]", "self", ".", "_initializers", "[", "\"w_dw\"", "]", "=", "create_weight_initializer", "(", "fan_in_shape", ",", "dtype", "=", "inputs", ".", "dtype", ")", "if", "\"w_pw\"", "not", "in", "self", ".", "_initializers", ":", "fan_in_shape", "=", "pointwise_weight_shape", "[", ":", "3", "]", "self", ".", "_initializers", "[", "\"w_pw\"", "]", "=", "create_weight_initializer", "(", "fan_in_shape", ",", "dtype", "=", "inputs", ".", "dtype", ")", "w_dw", "=", "tf", ".", "get_variable", "(", "\"w_dw\"", ",", "shape", "=", "depthwise_weight_shape", ",", "dtype", "=", "inputs", ".", "dtype", ",", "initializer", "=", "self", ".", "_initializers", "[", "\"w_dw\"", "]", ",", "partitioner", "=", "self", ".", "_partitioners", ".", "get", "(", "\"w_dw\"", ",", "None", ")", ",", "regularizer", "=", "self", ".", "_regularizers", ".", "get", "(", "\"w_dw\"", ",", "None", ")", ")", "w_pw", "=", "tf", ".", "get_variable", "(", "\"w_pw\"", ",", "shape", "=", "pointwise_weight_shape", ",", "dtype", "=", "inputs", ".", "dtype", ",", "initializer", "=", "self", ".", "_initializers", "[", "\"w_pw\"", "]", ",", "partitioner", "=", "self", ".", "_partitioners", ".", "get", "(", "\"w_pw\"", ",", "None", ")", ",", "regularizer", "=", "self", ".", "_regularizers", ".", "get", "(", "\"w_pw\"", ",", "None", ")", ")", "return", "w_dw", ",", "w_pw" ]

[ "Connects", "the", "module", "into", "the", "graph", "with", "input", "Tensor", "inputs", "." ]

[ "def", "_parse_geometry", "(", "geometry", ")", ":", "if", "isinstance", "(", "geometry", ",", "str", ")", ":", "geometry", "=", "shapely", ".", "wkt", ".", "loads", "(", "geometry", ")", "elif", "isinstance", "(", "geometry", ",", "dict", ")", ":", "geometry", "=", "shapely", ".", "geometry", ".", "shape", "(", "geometry", ")", "elif", "not", "isinstance", "(", "geometry", ",", "shapely", ".", "geometry", ".", "base", ".", "BaseGeometry", ")", ":", "raise", "TypeError", "(", "'Unsupported geometry representation'", ")", "if", "not", "isinstance", "(", "geometry", ",", "(", "shapely", ".", "geometry", ".", "Polygon", ",", "shapely", ".", "geometry", ".", "MultiPolygon", ")", ")", ":", "raise", "ValueError", "(", "'Supported geometry types are polygon and multipolygon, got {}'", ".", "format", "(", "type", "(", "geometry", ")", ")", ")", "return", "geometry" ]

[ "Parses", "given", "geometry", "into", "shapely", "object" ]

[ "def", "_add_arg_python", "(", "self", ",", "key", ",", "value", "=", "None", ",", "mask", "=", "False", ")", ":", "self", ".", "_data", "[", "key", "]", "=", "value", "if", "not", "value", ":", "# both false boolean values (flags) and empty values should not be added.", "pass", "elif", "value", "is", "True", ":", "# true boolean values are flags and should not contain a value", "self", ".", "_args", ".", "append", "(", "'--{}'", ".", "format", "(", "key", ")", ")", "self", ".", "_args_quoted", ".", "append", "(", "'--{}'", ".", "format", "(", "key", ")", ")", "self", ".", "_args_masked", ".", "append", "(", "'--{}'", ".", "format", "(", "key", ")", ")", "else", ":", "self", ".", "_args", ".", "append", "(", "'--{}={}'", ".", "format", "(", "key", ",", "value", ")", ")", "if", "mask", ":", "# mask sensitive values", "value", "=", "'x'", "*", "len", "(", "str", "(", "value", ")", ")", "else", ":", "# quote all values that would get displayed", "value", "=", "self", ".", "quote", "(", "value", ")", "self", ".", "_args_quoted", ".", "append", "(", "'--{}={}'", ".", "format", "(", "key", ",", "value", ")", ")", "self", ".", "_args_masked", ".", "append", "(", "'--{}={}'", ".", "format", "(", "key", ",", "value", ")", ")" ]

[ "Add", "CLI", "Arg", "formatted", "specifically", "for", "Python", "." ]

[ "def", "_create_page_control", "(", "self", ")", ":", "if", "self", ".", "custom_page_control", ":", "control", "=", "self", ".", "custom_page_control", "(", ")", "elif", "self", ".", "kind", "==", "'plain'", ":", "control", "=", "QtGui", ".", "QPlainTextEdit", "(", ")", "elif", "self", ".", "kind", "==", "'rich'", ":", "control", "=", "QtGui", ".", "QTextEdit", "(", ")", "control", ".", "installEventFilter", "(", "self", ")", "viewport", "=", "control", ".", "viewport", "(", ")", "viewport", ".", "installEventFilter", "(", "self", ")", "control", ".", "setReadOnly", "(", "True", ")", "control", ".", "setUndoRedoEnabled", "(", "False", ")", "control", ".", "setVerticalScrollBarPolicy", "(", "QtCore", ".", "Qt", ".", "ScrollBarAlwaysOn", ")", "return", "control" ]

[ "Creates", "and", "connects", "the", "underlying", "paging", "widget", "." ]

[ "def", "limit", "(", "self", ",", "limit_value", ",", "key_func", "=", "None", ",", "per_method", "=", "False", ",", "methods", "=", "None", ",", "error_message", "=", "None", ",", "exempt_when", "=", "None", ")", ":", "return", "self", ".", "__limit_decorator", "(", "limit_value", ",", "key_func", ",", "per_method", "=", "per_method", ",", "methods", "=", "methods", ",", "error_message", "=", "error_message", ",", "exempt_when", "=", "exempt_when", ")" ]

[ "decorator", "to", "be", "used", "for", "rate", "limiting", "individual", "routes", "." ]

[ "def", "ruamel_structure", "(", "data", ",", "validator", "=", "None", ")", ":", "if", "isinstance", "(", "data", ",", "dict", ")", ":", "if", "len", "(", "data", ")", "==", "0", ":", "raise", "exceptions", ".", "CannotBuildDocumentsFromEmptyDictOrList", "(", "\"Document must be built with non-empty dicts and lists\"", ")", "return", "CommentedMap", "(", "[", "(", "ruamel_structure", "(", "key", ")", ",", "ruamel_structure", "(", "value", ")", ")", "for", "key", ",", "value", "in", "data", ".", "items", "(", ")", "]", ")", "elif", "isinstance", "(", "data", ",", "list", ")", ":", "if", "len", "(", "data", ")", "==", "0", ":", "raise", "exceptions", ".", "CannotBuildDocumentsFromEmptyDictOrList", "(", "\"Document must be built with non-empty dicts and lists\"", ")", "return", "CommentedSeq", "(", "[", "ruamel_structure", "(", "item", ")", "for", "item", "in", "data", "]", ")", "elif", "isinstance", "(", "data", ",", "bool", ")", ":", "return", "u\"yes\"", "if", "data", "else", "u\"no\"", "elif", "isinstance", "(", "data", ",", "(", "int", ",", "float", ")", ")", ":", "return", "str", "(", "data", ")", "else", ":", "if", "not", "is_string", "(", "data", ")", ":", "raise", "exceptions", ".", "CannotBuildDocumentFromInvalidData", "(", "(", "\"Document must be built from a combination of:\\n\"", "\"string, int, float, bool or nonempty list/dict\\n\\n\"", "\"Instead, found variable with type '{}': '{}'\"", ")", ".", "format", "(", "type", "(", "data", ")", ".", "__name__", ",", "data", ")", ")", "return", "data" ]

[ "Take", "dicts", "and", "lists", "and", "return", "a", "ruamel", ".", "yaml", "style", "structure", "of", "CommentedMaps", "CommentedSeqs", "and", "data", "." ]

[ "def", "_copy_selection", "(", "self", ",", "*", "event", ")", ":", "if", "react_to_event", "(", "self", ".", "view", ",", "self", ".", "view", ".", "editor", ",", "event", ")", ":", "logger", ".", "debug", "(", "\"copy selection\"", ")", "global_clipboard", ".", "copy", "(", "self", ".", "model", ".", "selection", ")", "return", "True" ]

[ "Copies", "the", "current", "selection", "to", "the", "clipboard", "." ]

[ "def", "getquals", "(", "args", ")", ":", "p", "=", "OptionParser", "(", "getquals", ".", "__doc__", ")", "p", ".", "add_option", "(", "\"--types\"", ",", "default", "=", "\"gene,mRNA,CDS\"", ",", "type", "=", "\"str\"", ",", "dest", "=", "\"quals_ftypes\"", ",", "help", "=", "\"Feature types from which to extract qualifiers\"", ")", "p", ".", "add_option", "(", "\"--ignore\"", ",", "default", "=", "\"locus_tag,product,codon_start,translation\"", ",", "type", "=", "\"str\"", ",", "dest", "=", "\"quals_ignore\"", ",", "help", "=", "\"Qualifiers to exclude from parsing\"", ")", "opts", ",", "args", "=", "p", ".", "parse_args", "(", "args", ")", "if", "len", "(", "args", ")", "!=", "1", ":", "sys", ".", "exit", "(", "not", "p", ".", "print_help", "(", ")", ")", "gbkfile", ",", "=", "args", "quals_ftypes", "=", "opts", ".", "quals_ftypes", ".", "split", "(", "\",\"", ")", "quals_ignore", "=", "opts", ".", "quals_ignore", ".", "split", "(", "\",\"", ")", "locus", "=", "dict", "(", ")", "locus_tag", "=", "None", "for", "rec", "in", "SeqIO", ".", "parse", "(", "gbkfile", ",", "\"gb\"", ")", ":", "for", "f", "in", "rec", ".", "features", ":", "if", "f", ".", "type", "in", "quals_ftypes", ":", "locus_tag", "=", "f", ".", "qualifiers", "[", "LT", "]", "[", "0", "]", "if", "locus_tag", "not", "in", "locus", ":", "locus", "[", "locus_tag", "]", "=", "dict", "(", ")", "for", "ftype", "in", "quals_ftypes", ":", "if", "ftype", "not", "in", "locus", "[", "locus_tag", "]", ":", "locus", "[", "locus_tag", "]", "[", "ftype", "]", "=", "[", "]", "if", "ftype", "==", "\"CDS\"", ":", "# store the CDS protein_id", "locus", "[", "locus_tag", "]", "[", "\"protein_id\"", "]", "=", "[", "]", "quals", "=", "[", "]", "for", "qual", "in", "f", ".", "qualifiers", ":", "if", "qual", "in", "quals_ignore", ":", "continue", "for", "qval", "in", "f", ".", "qualifiers", "[", "qual", "]", ":", "quals", ".", "append", "(", "(", "locus_tag", ",", "qual", ",", "qval", ")", ")", "if", "qual", "==", "\"protein_id\"", ":", "locus", "[", "locus_tag", "]", "[", "\"protein_id\"", "]", ".", "append", "(", "qval", ")", "if", "len", "(", "quals", ")", ">", "0", ":", "locus", "[", "locus_tag", "]", "[", "f", ".", "type", "]", ".", "append", "(", "quals", ")", "for", "locus_tag", "in", "locus", ":", "print_locus_quals", "(", "locus_tag", ",", "locus", ",", "quals_ftypes", ")" ]

[ "%prog", "getquals", "[", "--", "options", "]", "gbkfile", ">", "qualsfile" ]

[ "def", "SetPlatformArchContext", "(", ")", ":", "# Initialize the running platform context:", "_CONFIG", ".", "AddContext", "(", "\"Platform:%s\"", "%", "platform", ".", "system", "(", ")", ".", "title", "(", ")", ")", "machine", "=", "platform", ".", "uname", "(", ")", "[", "4", "]", "if", "machine", "in", "[", "\"x86_64\"", ",", "\"AMD64\"", ",", "\"i686\"", "]", ":", "# 32 bit binaries running on AMD64 will still have a i386 arch.", "if", "platform", ".", "architecture", "(", ")", "[", "0", "]", "==", "\"32bit\"", ":", "arch", "=", "\"i386\"", "else", ":", "arch", "=", "\"amd64\"", "elif", "machine", "==", "\"x86\"", ":", "arch", "=", "\"i386\"", "else", ":", "arch", "=", "machine", "_CONFIG", ".", "AddContext", "(", "\"Arch:%s\"", "%", "arch", ")" ]

[ "Add", "the", "running", "contexts", "to", "the", "config", "system", "." ]

[ "def", "logBranch", "(", "self", ",", "indent", "=", "0", ",", "level", "=", "logging", ".", "DEBUG", ")", ":", "if", "0", ":", "print", "(", "indent", "*", "\" \"", "+", "str", "(", "self", ")", ")", "else", ":", "logger", ".", "log", "(", "level", ",", "indent", "*", "\" \"", "+", "str", "(", "self", ")", ")", "for", "childItems", "in", "self", ".", "childItems", ":", "childItems", ".", "logBranch", "(", "indent", "+", "1", ",", "level", "=", "level", ")" ]

[ "Logs", "the", "item", "and", "all", "descendants", "one", "line", "per", "child" ]

[ "def", "rev_comp", "(", "seq", ")", ":", "rev_seq", "=", "seq", "[", ":", ":", "-", "1", "]", "rev_comp_seq", "=", "''", ".", "join", "(", "[", "base_pairing", "[", "s", "]", "for", "s", "in", "rev_seq", "]", ")", "return", "rev_comp_seq" ]

[ "Get", "reverse", "complement", "of", "sequence", "." ]

[ "def", "local_open", "(", "url", ")", ":", "scheme", ",", "server", ",", "path", ",", "param", ",", "query", ",", "frag", "=", "urllib", ".", "parse", ".", "urlparse", "(", "url", ")", "filename", "=", "urllib", ".", "request", ".", "url2pathname", "(", "path", ")", "if", "os", ".", "path", ".", "isfile", "(", "filename", ")", ":", "return", "urllib", ".", "request", ".", "urlopen", "(", "url", ")", "elif", "path", ".", "endswith", "(", "'/'", ")", "and", "os", ".", "path", ".", "isdir", "(", "filename", ")", ":", "files", "=", "[", "]", "for", "f", "in", "os", ".", "listdir", "(", "filename", ")", ":", "filepath", "=", "os", ".", "path", ".", "join", "(", "filename", ",", "f", ")", "if", "f", "==", "'index.html'", ":", "with", "open", "(", "filepath", ",", "'r'", ")", "as", "fp", ":", "body", "=", "fp", ".", "read", "(", ")", "break", "elif", "os", ".", "path", ".", "isdir", "(", "filepath", ")", ":", "f", "+=", "'/'", "files", ".", "append", "(", "'<a href=\"{name}\">{name}</a>'", ".", "format", "(", "name", "=", "f", ")", ")", "else", ":", "tmpl", "=", "(", "\"<html><head><title>{url}</title>\"", "\"</head><body>{files}</body></html>\"", ")", "body", "=", "tmpl", ".", "format", "(", "url", "=", "url", ",", "files", "=", "'\\n'", ".", "join", "(", "files", ")", ")", "status", ",", "message", "=", "200", ",", "\"OK\"", "else", ":", "status", ",", "message", ",", "body", "=", "404", ",", "\"Path not found\"", ",", "\"Not found\"", "headers", "=", "{", "'content-type'", ":", "'text/html'", "}", "body_stream", "=", "six", ".", "StringIO", "(", "body", ")", "return", "urllib", ".", "error", ".", "HTTPError", "(", "url", ",", "status", ",", "message", ",", "headers", ",", "body_stream", ")" ]

[ "Read", "a", "local", "path", "with", "special", "support", "for", "directories" ]

[ "def", "cmd_tcpscan", "(", "ip", ",", "port", ",", "iface", ",", "flags", ",", "sleeptime", ",", "timeout", ",", "show_all", ",", "verbose", ")", ":", "if", "verbose", ":", "logging", ".", "basicConfig", "(", "level", "=", "logging", ".", "INFO", ",", "format", "=", "'%(message)s'", ")", "conf", ".", "verb", "=", "False", "if", "iface", ":", "conf", ".", "iface", "=", "iface", "port_regex", "=", "r'^[0-9,-]+$'", "if", "not", "re", ".", "match", "(", "port_regex", ",", "port", ")", ":", "logging", ".", "critical", "(", "\"Invalid port specification\"", ")", "return", "False", "ports", "=", "[", "]", "for", "p", "in", "str", "(", "port", ")", ".", "split", "(", "','", ")", ":", "if", "'-'", "in", "p", ":", "first", ",", "last", "=", "p", ".", "split", "(", "'-'", ")", "for", "n", "in", "range", "(", "int", "(", "first", ")", ",", "int", "(", "last", ")", "+", "1", ")", ":", "ports", ".", "append", "(", "n", ")", "else", ":", "ports", ".", "append", "(", "int", "(", "p", ")", ")", "out", "=", "\"{port} {sflags} -> {rflags}\"", "pkts", "=", "IP", "(", "dst", "=", "ip", ")", "/", "TCP", "(", "flags", "=", "flags", ",", "dport", "=", "ports", ")", "if", "sleeptime", ":", "res", "=", "[", "]", "for", "pkt", "in", "pkts", ":", "logging", ".", "info", "(", "pkt", ".", "summary", "(", ")", ")", "_", "=", "sr1", "(", "pkt", ")", "if", "_", ":", "logging", ".", "info", "(", "_", ".", "summary", "(", ")", ")", "res", ".", "append", "(", "(", "pkt", ",", "_", ")", ")", "else", ":", "res", ",", "unans", "=", "sr", "(", "pkts", ",", "verbose", "=", "verbose", ")", "for", "s", ",", "r", "in", "res", ":", "if", "show_all", "or", "'S'", "in", "r", ".", "sprintf", "(", "r\"%TCP.flags%\"", ")", ":", "print", "(", "out", ".", "format", "(", "port", "=", "s", "[", "TCP", "]", ".", "dport", ",", "sflags", "=", "s", ".", "sprintf", "(", "r\"%TCP.flags%\"", ")", ",", "rflags", "=", "r", ".", "sprintf", "(", "r\"%TCP.flags%\"", ")", ")", ")" ]

[ "TCP", "Port", "Scanner", "." ]

[ "def", "options", "(", "argv", "=", "[", "]", ")", ":", "parser", "=", "HendrixOptionParser", "parsed_args", "=", "parser", ".", "parse_args", "(", "argv", ")", "return", "vars", "(", "parsed_args", "[", "0", "]", ")" ]

[ "A", "helper", "function", "that", "returns", "a", "dictionary", "of", "the", "default", "key", "-", "values", "pairs" ]

[ "def", "ber_code", "(", "self", ")", ":", "try", ":", "alt_text", "=", "self", ".", "_ad_page_content", ".", "find", "(", "'span'", ",", "{", "'class'", ":", "'ber-hover'", "}", ")", ".", "find", "(", "'img'", ")", "[", "'alt'", "]", "if", "(", "'exempt'", "in", "alt_text", ")", ":", "return", "'exempt'", "else", ":", "alt_arr", "=", "alt_text", ".", "split", "(", ")", "if", "'ber'", "in", "alt_arr", "[", "0", "]", ".", "lower", "(", ")", ":", "return", "alt_arr", "[", "1", "]", ".", "lower", "(", ")", "else", ":", "return", "None", "except", "Exception", "as", "e", ":", "if", "self", ".", "_debug", ":", "logging", ".", "error", "(", "\"Error getting the Ber Code. Error message: \"", "+", "e", ".", "args", "[", "0", "]", ")", "return", "None" ]

[ "This", "method", "gets", "ber", "code", "listed", "in", "Daft", ".", ":", "return", ":" ]

[ "def", "is_img_id_valid", "(", "img_id", ")", ":", "t", "=", "re", ".", "sub", "(", "r'[^a-z0-9_:\\-\\.]'", ",", "''", ",", "img_id", ",", "re", ".", "IGNORECASE", ")", "t", "=", "re", ".", "sub", "(", "r'\\.+'", ",", "'.'", ",", "t", ")", "if", "img_id", "!=", "t", "or", "img_id", ".", "count", "(", "':'", ")", "!=", "1", ":", "return", "False", "profile", ",", "base_name", "=", "img_id", ".", "split", "(", "':'", ",", "1", ")", "if", "not", "profile", "or", "not", "base_name", ":", "return", "False", "try", ":", "get_profile_configs", "(", "profile", ")", "except", "ValueError", ":", "return", "False", "return", "True" ]

[ "Checks", "if", "img_id", "is", "valid", "." ]

[ "def", "mean_by_panel", "(", "self", ",", "length", ")", ":", "self", ".", "_check_panel", "(", "length", ")", "func", "=", "lambda", "v", ":", "v", ".", "reshape", "(", "-", "1", ",", "length", ")", ".", "mean", "(", "axis", "=", "0", ")", "newindex", "=", "arange", "(", "length", ")", "return", "self", ".", "map", "(", "func", ",", "index", "=", "newindex", ")" ]

[ "Compute", "the", "mean", "across", "fixed", "sized", "panels", "of", "each", "record", "." ]

[ "def", "check_str", "(", "obj", ")", ":", "if", "isinstance", "(", "obj", ",", "str", ")", ":", "return", "obj", "if", "isinstance", "(", "obj", ",", "float", ")", ":", "return", "str", "(", "int", "(", "obj", ")", ")", "else", ":", "return", "str", "(", "obj", ")" ]

[ "Returns", "a", "string", "for", "various", "input", "types" ]

[ "def", "_parse_wsgi_headers", "(", "wsgi_environ", ")", ":", "prefix", "=", "'HTTP_'", "p_len", "=", "len", "(", "prefix", ")", "# use .items() despite suspected memory pressure bc GC occasionally", "# collects wsgi_environ.iteritems() during iteration.", "headers", "=", "{", "key", "[", "p_len", ":", "]", ".", "replace", "(", "'_'", ",", "'-'", ")", ".", "lower", "(", ")", ":", "val", "for", "(", "key", ",", "val", ")", "in", "wsgi_environ", ".", "items", "(", ")", "if", "key", ".", "startswith", "(", "prefix", ")", "}", "return", "headers" ]

[ "HTTP", "headers", "are", "presented", "in", "WSGI", "environment", "with", "HTTP_", "prefix", ".", "This", "method", "finds", "those", "headers", "removes", "the", "prefix", "converts", "underscores", "to", "dashes", "and", "converts", "to", "lower", "case", "." ]

[ "def", "consume_changes", "(", "self", ",", "start", ",", "end", ")", ":", "left", ",", "right", "=", "self", ".", "_get_changed", "(", "start", ",", "end", ")", "if", "left", "<", "right", ":", "del", "self", ".", "lines", "[", "left", ":", "right", "]", "return", "left", "<", "right" ]

[ "Clear", "the", "changed", "status", "of", "lines", "from", "start", "till", "end" ]

[ "async", "def", "deregister", "(", "self", ",", "check", ")", ":", "check_id", "=", "extract_attr", "(", "check", ",", "keys", "=", "[", "\"CheckID\"", ",", "\"ID\"", "]", ")", "response", "=", "await", "self", ".", "_api", ".", "get", "(", "\"/v1/agent/check/deregister\"", ",", "check_id", ")", "return", "response", ".", "status", "==", "200" ]

[ "Deregisters", "a", "local", "check" ]

[ "def", "set", "(", "ctx", ",", "key", ",", "value", ")", ":", "if", "key", "==", "\"default_account\"", "and", "value", "[", "0", "]", "==", "\"@\"", ":", "value", "=", "value", "[", "1", ":", "]", "ctx", ".", "bitshares", ".", "config", "[", "key", "]", "=", "value" ]

[ "Set", "configuration", "parameters" ]

[ "def", "price_change", "(", "self", ")", ":", "try", ":", "if", "self", ".", "_data_from_search", ":", "return", "self", ".", "_data_from_search", ".", "find", "(", "'div'", ",", "{", "'class'", ":", "'price-changes-sr'", "}", ")", ".", "text", "else", ":", "return", "self", ".", "_ad_page_content", ".", "find", "(", "'div'", ",", "{", "'class'", ":", "'price-changes-sr'", "}", ")", ".", "text", "except", "Exception", "as", "e", ":", "if", "self", ".", "_debug", ":", "logging", ".", "error", "(", "\"Error getting price_change. Error message: \"", "+", "e", ".", "args", "[", "0", "]", ")", "return" ]

[ "This", "method", "returns", "any", "price", "change", ".", ":", "return", ":" ]

[ "def", "fromJSON", "(", "value", ")", ":", "j", "=", "json", ".", "loads", "(", "value", ")", "v", "=", "GPString", "(", ")", "if", "\"defaultValue\"", "in", "j", ":", "v", ".", "value", "=", "j", "[", "'defaultValue'", "]", "else", ":", "v", ".", "value", "=", "j", "[", "'value'", "]", "if", "'paramName'", "in", "j", ":", "v", ".", "paramName", "=", "j", "[", "'paramName'", "]", "elif", "'name'", "in", "j", ":", "v", ".", "paramName", "=", "j", "[", "'name'", "]", "return", "v" ]

[ "loads", "the", "GP", "object", "from", "a", "JSON", "string" ]

[ "def", "delete_image", "(", "self", ",", "identifier", ")", ":", "if", "isinstance", "(", "identifier", ",", "dict", ")", ":", "identifier", "=", "identifier", ".", "get", "(", "'id'", ",", "''", ")", "j", ",", "r", "=", "self", ".", "request", "(", "'DELETE'", ",", "'/images/'", "+", "str", "(", "identifier", ")", ")", "r", ".", "raise_for_status", "(", ")", "return", "j" ]

[ "::", "DELETE", "/", ":", "login", "/", "images", "/", ":", "id", ":", "param", "identifier", ":", "match", "on", "the", "listed", "image", "identifier", ":", "type", "identifier", ":", ":", "py", ":", "class", ":", "basestring", "or", ":", "py", ":", "class", ":", "dict", "A", "string", "or", "a", "dictionary", "containing", "an", "id", "key", "may", "be", "passed", "in", ".", "Will", "raise", "an", "error", "if", "the", "response", "was", "an", "error", "." ]

[ "def", "remove_entry", "(", "self", ",", "entry", ")", ":", "if", "not", "isinstance", "(", "entry", ",", "Entry", ")", ":", "raise", "TypeError", "(", "\"entry param must be of type Entry.\"", ")", "if", "not", "entry", "in", "self", ".", "entries", ":", "raise", "ValueError", "(", "\"Entry doesn't exist / not bound to this datbase.\"", ")", "entry", ".", "group", ".", "entries", ".", "remove", "(", "entry", ")", "self", ".", "entries", ".", "remove", "(", "entry", ")" ]

[ "Remove", "specified", "entry", ".", ":", "param", "entry", ":", "The", "Entry", "object", "to", "remove", ".", ":", "type", "entry", ":", ":", "class", ":", "keepassdb", ".", "model", ".", "Entry" ]

[ "def", "addText", "(", "self", ",", "text", ")", ":", "# move to the end of the doc", "self", ".", "moveCursor", "(", "QtGui", ".", "QTextCursor", ".", "End", ")", "# insert the text", "self", ".", "setTextColor", "(", "self", ".", "_currentColor", ")", "self", ".", "textCursor", "(", ")", ".", "insertText", "(", "text", ")" ]

[ "append", "text", "in", "the", "chosen", "color" ]

[ "def", "robot_files", "(", "self", ")", ":", "result", "=", "[", "]", "for", "name", "in", "os", ".", "listdir", "(", "self", ".", "path", ")", ":", "fullpath", "=", "os", ".", "path", ".", "join", "(", "self", ".", "path", ",", "name", ")", "if", "os", ".", "path", ".", "isdir", "(", "fullpath", ")", ":", "result", ".", "append", "(", "RobotFactory", "(", "fullpath", ",", "parent", "=", "self", ")", ")", "else", ":", "if", "(", "(", "name", ".", "endswith", "(", "\".txt\"", ")", "or", "name", ".", "endswith", "(", "\".robot\"", ")", ")", "and", "(", "name", "not", "in", "(", "\"__init__.txt\"", ",", "\"__init__.robot\"", ")", ")", ")", ":", "result", ".", "append", "(", "RobotFactory", "(", "fullpath", ",", "parent", "=", "self", ")", ")", "return", "result" ]

[ "Return", "a", "list", "of", "all", "folders", "and", "test", "suite", "files", "(", ".", "txt", ".", "robot", ")" ]

[ "def", "load_preferences", "(", "session", ",", "config", ",", "valid_paths", ",", "cull_disabled", "=", "False", ",", "openid", "=", "None", ",", "cull_backends", "=", "None", ")", ":", "cull_backends", "=", "cull_backends", "or", "[", "]", "query", "=", "session", ".", "query", "(", "fmn", ".", "lib", ".", "models", ".", "Preference", ")", "if", "openid", ":", "query", "=", "query", ".", "filter", "(", "fmn", ".", "lib", ".", "models", ".", "Preference", ".", "openid", "==", "openid", ")", "preferences", "=", "query", ".", "all", "(", ")", "return", "[", "preference", ".", "__json__", "(", "reify", "=", "True", ")", "for", "preference", "in", "preferences", "if", "(", "preference", ".", "context", ".", "name", "in", "config", "[", "'fmn.backends'", "]", "and", "preference", ".", "context", ".", "name", "not", "in", "cull_backends", "and", "(", "not", "cull_disabled", "or", "preference", ".", "enabled", ")", ")", "]" ]

[ "Every", "rule", "for", "every", "filter", "for", "every", "context", "for", "every", "user", "." ]

[ "def", "GetRowHeaders", "(", "self", ")", "->", "list", ":", "eleArray", "=", "self", ".", "pattern", ".", "GetCurrentRowHeaders", "(", ")", "if", "eleArray", ":", "controls", "=", "[", "]", "for", "i", "in", "range", "(", "eleArray", ".", "Length", ")", ":", "ele", "=", "eleArray", ".", "GetElement", "(", "i", ")", "con", "=", "Control", ".", "CreateControlFromElement", "(", "element", "=", "ele", ")", "if", "con", ":", "controls", ".", "append", "(", "con", ")", "return", "controls", "return", "[", "]" ]

[ "Call", "IUIAutomationTablePattern", "::", "GetCurrentRowHeaders", ".", "Return", "list", "a", "list", "of", "Control", "subclasses", "representing", "all", "the", "row", "headers", "in", "a", "table", ".", "Refer", "https", ":", "//", "docs", ".", "microsoft", ".", "com", "/", "en", "-", "us", "/", "windows", "/", "desktop", "/", "api", "/", "uiautomationclient", "/", "nf", "-", "uiautomationclient", "-", "iuiautomationtablepattern", "-", "getcurrentrowheaders" ]

[ "def", "get_instance", "(", "self", ",", "payload", ")", ":", "return", "MonthlyInstance", "(", "self", ".", "_version", ",", "payload", ",", "account_sid", "=", "self", ".", "_solution", "[", "'account_sid'", "]", ",", ")" ]

[ "Build", "an", "instance", "of", "MonthlyInstance" ]

[ "def", "delete_collection_pod_security_policy", "(", "self", ",", "*", "*", "kwargs", ")", ":", "kwargs", "[", "'_return_http_data_only'", "]", "=", "True", "if", "kwargs", ".", "get", "(", "'async_req'", ")", ":", "return", "self", ".", "delete_collection_pod_security_policy_with_http_info", "(", "*", "*", "kwargs", ")", "else", ":", "(", "data", ")", "=", "self", ".", "delete_collection_pod_security_policy_with_http_info", "(", "*", "*", "kwargs", ")", "return", "data" ]

[ "delete", "collection", "of", "PodSecurityPolicy", "This", "method", "makes", "a", "synchronous", "HTTP", "request", "by", "default", ".", "To", "make", "an", "asynchronous", "HTTP", "request", "please", "pass", "async_req", "=", "True", ">>>", "thread", "=", "api", ".", "delete_collection_pod_security_policy", "(", "async_req", "=", "True", ")", ">>>", "result", "=", "thread", ".", "get", "()" ]

[ "def", "contains_entry", "(", "self", ",", "key", ",", "value", ")", ":", "check_not_none", "(", "key", ",", "\"key can't be None\"", ")", "check_not_none", "(", "value", ",", "\"value can't be None\"", ")", "key_data", "=", "self", ".", "_to_data", "(", "key", ")", "value_data", "=", "self", ".", "_to_data", "(", "value", ")", "return", "self", ".", "_encode_invoke_on_key", "(", "multi_map_contains_entry_codec", ",", "key_data", ",", "key", "=", "key_data", ",", "value", "=", "value_data", ",", "thread_id", "=", "thread_id", "(", ")", ")" ]

[ "Returns", "whether", "the", "multimap", "contains", "an", "entry", "with", "the", "value", "." ]

[ "def", "parse_and_normalize_url_date", "(", "date_str", ")", ":", "if", "date_str", "is", "None", ":", "return", "None", "try", ":", "return", "d1_common", ".", "date_time", ".", "dt_from_iso8601_str", "(", "date_str", ")", "except", "d1_common", ".", "date_time", ".", "iso8601", ".", "ParseError", "as", "e", ":", "raise", "d1_common", ".", "types", ".", "exceptions", ".", "InvalidRequest", "(", "0", ",", "'Invalid date format for URL parameter. date=\"{}\" error=\"{}\"'", ".", "format", "(", "date_str", ",", "str", "(", "e", ")", ")", ",", ")" ]

[ "Parse", "a", "ISO", "8601", "date", "-", "time", "with", "optional", "timezone", "." ]

[ "def", "create_layout", "(", "self", ",", "size", "=", "None", ")", ":", "if", "not", "self", ".", "context", ":", "# TODO - this is rather sloppy as far as exception goes", "# should explain better", "raise", "Exception", "(", "\"Can not create layout without existing context!\"", ")", "layout", "=", "pangocairo", ".", "create_layout", "(", "self", ".", "context", ")", "font_desc", "=", "pango", ".", "FontDescription", "(", "_font_desc", ")", "if", "size", ":", "font_desc", ".", "set_absolute_size", "(", "size", "*", "pango", ".", "SCALE", ")", "layout", ".", "set_font_description", "(", "font_desc", ")", "return", "layout" ]

[ "utility", "function", "to", "create", "layout", "with", "the", "default", "font", ".", "Size", "and", "alignment", "parameters", "are", "shortcuts", "to", "according", "functions", "of", "the", "pango", ".", "Layout" ]

[ "def", "merge_code", "(", "left_code", ",", "right_code", ")", ":", "data", "=", "dict", "(", ")", "code_lines", "=", "(", "left_code", "and", "left_code", ".", "iter_code_by_lines", "(", ")", ")", "or", "tuple", "(", ")", "for", "abs_line", ",", "rel_line", ",", "dis", "in", "code_lines", ":", "data", "[", "rel_line", "]", "=", "[", "(", "abs_line", ",", "dis", ")", ",", "None", "]", "code_lines", "=", "(", "right_code", "and", "right_code", ".", "iter_code_by_lines", "(", ")", ")", "or", "tuple", "(", ")", "for", "abs_line", ",", "rel_line", ",", "dis", "in", "code_lines", ":", "found", "=", "data", ".", "get", "(", "rel_line", ",", "None", ")", "if", "found", "is", "None", ":", "found", "=", "[", "None", ",", "(", "abs_line", ",", "dis", ")", "]", "data", "[", "rel_line", "]", "=", "found", "else", ":", "found", "[", "1", "]", "=", "(", "abs_line", ",", "dis", ")", "return", "data" ]

[ "{", "relative_line", ":", "((", "left_abs_line", "((", "offset", "op", "args", ")", "...", "))", "(", "right_abs_line", "((", "offset", "op", "args", ")", "...", ")))", "...", "}" ]

[ "def", "light_to_gl", "(", "light", ",", "transform", ",", "lightN", ")", ":", "# convert color to opengl", "gl_color", "=", "vector_to_gl", "(", "light", ".", "color", ".", "astype", "(", "np", ".", "float64", ")", "/", "255.0", ")", "assert", "len", "(", "gl_color", ")", "==", "4", "# cartesian translation from matrix", "gl_position", "=", "vector_to_gl", "(", "transform", "[", ":", "3", ",", "3", "]", ")", "# create the different position and color arguments", "args", "=", "[", "(", "lightN", ",", "gl", ".", "GL_POSITION", ",", "gl_position", ")", ",", "(", "lightN", ",", "gl", ".", "GL_SPECULAR", ",", "gl_color", ")", ",", "(", "lightN", ",", "gl", ".", "GL_DIFFUSE", ",", "gl_color", ")", ",", "(", "lightN", ",", "gl", ".", "GL_AMBIENT", ",", "gl_color", ")", "]", "return", "args" ]

[ "Convert", "trimesh", ".", "scene", ".", "lighting", ".", "Light", "objects", "into", "args", "for", "gl", ".", "glLightFv", "calls" ]

[ "async", "def", "pause", "(", "self", ",", "pause", ":", "bool", "=", "True", ")", ":", "self", ".", "_paused", "=", "pause", "await", "self", ".", "node", ".", "pause", "(", "self", ".", "channel", ".", "guild", ".", "id", ",", "pause", ")" ]

[ "Pauses", "the", "current", "song", "." ]

[ "def", "_rotate_tr", "(", "self", ")", ":", "rot", ",", "x", ",", "y", ",", "z", "=", "self", ".", "_quaternion", ".", "get_axis_angle", "(", ")", "up", ",", "forward", ",", "right", "=", "self", ".", "_get_dim_vectors", "(", ")", "self", ".", "transform", ".", "rotate", "(", "180", "*", "rot", "/", "np", ".", "pi", ",", "(", "x", ",", "z", ",", "y", ")", ")" ]

[ "Rotate", "the", "transformation", "matrix", "based", "on", "camera", "parameters" ]

[ "def", "_cbc_decrypt", "(", "self", ",", "final_key", ",", "crypted_content", ")", ":", "# Just decrypt the content with the created key", "aes", "=", "AES", ".", "new", "(", "final_key", ",", "AES", ".", "MODE_CBC", ",", "self", ".", "_enc_iv", ")", "decrypted_content", "=", "aes", ".", "decrypt", "(", "crypted_content", ")", "padding", "=", "decrypted_content", "[", "-", "1", "]", "if", "sys", ".", "version", ">", "'3'", ":", "padding", "=", "decrypted_content", "[", "-", "1", "]", "else", ":", "padding", "=", "ord", "(", "decrypted_content", "[", "-", "1", "]", ")", "decrypted_content", "=", "decrypted_content", "[", ":", "len", "(", "decrypted_content", ")", "-", "padding", "]", "return", "decrypted_content" ]

[ "This", "method", "decrypts", "the", "database" ]

[ "def", "add_sent", "(", "self", ",", "sent_obj", ")", ":", "if", "sent_obj", "is", "None", ":", "raise", "Exception", "(", "\"Sentence object cannot be None\"", ")", "elif", "sent_obj", ".", "ID", "is", "None", ":", "# if sentID is None, create a new ID", "sent_obj", ".", "ID", "=", "next", "(", "self", ".", "__idgen", ")", "elif", "self", ".", "has_id", "(", "sent_obj", ".", "ID", ")", ":", "raise", "Exception", "(", "\"Sentence ID {} exists\"", ".", "format", "(", "sent_obj", ".", "ID", ")", ")", "self", ".", "__sent_map", "[", "sent_obj", ".", "ID", "]", "=", "sent_obj", "self", ".", "__sents", ".", "append", "(", "sent_obj", ")", "return", "sent_obj" ]

[ "Add", "a", "ttl", ".", "Sentence", "object", "to", "this", "document" ]

[ "def", "save", "(", "self", ",", "set_cookie", ",", "*", "*", "params", ")", ":", "if", "set", "(", "self", ".", "store", ".", "items", "(", ")", ")", "^", "set", "(", "self", ".", "items", "(", ")", ")", ":", "value", "=", "dict", "(", "self", ".", "items", "(", ")", ")", "value", "=", "json", ".", "dumps", "(", "value", ")", "value", "=", "self", ".", "encrypt", "(", "value", ")", "if", "not", "isinstance", "(", "value", ",", "str", ")", ":", "value", "=", "value", ".", "encode", "(", "self", ".", "encoding", ")", "set_cookie", "(", "self", ".", "key", ",", "value", ",", "*", "*", "self", ".", "params", ")", "return", "True", "return", "False" ]

[ "Update", "cookies", "if", "the", "session", "has", "been", "changed", "." ]

[ "async", "def", "teardown_client", "(", "self", ",", "client_id", ")", ":", "client_info", "=", "self", ".", "_client_info", "(", "client_id", ")", "self", ".", "adapter", ".", "remove_monitor", "(", "client_info", "[", "'monitor'", "]", ")", "conns", "=", "client_info", "[", "'connections'", "]", "for", "conn_string", ",", "conn_id", "in", "conns", ".", "items", "(", ")", ":", "try", ":", "self", ".", "_logger", ".", "debug", "(", "\"Disconnecting client %s from conn %s at teardown\"", ",", "client_id", ",", "conn_string", ")", "await", "self", ".", "adapter", ".", "disconnect", "(", "conn_id", ")", "except", ":", "#pylint:disable=bare-except; This is a finalization method that should not raise unexpectedly", "self", ".", "_logger", ".", "exception", "(", "\"Error disconnecting device during teardown_client: conn_string=%s\"", ",", "conn_string", ")", "del", "self", ".", "_clients", "[", "client_id", "]" ]

[ "Release", "all", "resources", "held", "by", "a", "client", "." ]

[ "def", "set_data_length", "(", "self", ",", "length", ")", ":", "# type: (int) -> None", "if", "not", "self", ".", "_initialized", ":", "raise", "pycdlibexception", ".", "PyCdlibInternalError", "(", "'Directory Record not yet initialized'", ")", "len_diff", "=", "length", "-", "self", ".", "info_len", "if", "len_diff", ">", "0", ":", "# If we are increasing the length, update the last alloc_desc up", "# to the max of 0x3ffff800, and throw an exception if we overflow.", "new_len", "=", "self", ".", "alloc_descs", "[", "-", "1", "]", "[", "0", "]", "+", "len_diff", "if", "new_len", ">", "0x3ffff800", ":", "raise", "pycdlibexception", ".", "PyCdlibInvalidInput", "(", "'Cannot increase the size of a UDF file beyond the current descriptor'", ")", "self", ".", "alloc_descs", "[", "-", "1", "]", "[", "0", "]", "=", "new_len", "elif", "len_diff", "<", "0", ":", "# We are decreasing the length. It's possible we are removing one", "# or more alloc_descs, so run through the list updating all of the", "# descriptors and remove any we no longer need.", "len_left", "=", "length", "alloc_descs_needed", "=", "0", "index", "=", "0", "while", "len_left", ">", "0", ":", "this_len", "=", "min", "(", "len_left", ",", "0x3ffff800", ")", "alloc_descs_needed", "+=", "1", "self", ".", "alloc_descs", "[", "index", "]", "[", "0", "]", "=", "this_len", "index", "+=", "1", "len_left", "-=", "this_len", "self", ".", "alloc_descs", "=", "self", ".", "alloc_descs", "[", ":", "alloc_descs_needed", "]", "self", ".", "info_len", "=", "length" ]

[ "A", "method", "to", "set", "the", "length", "of", "the", "data", "that", "this", "UDF", "File", "Entry", "points", "to", "." ]

[ "def", "rsi", "(", "self", ",", "n", ",", "array", "=", "False", ")", ":", "result", "=", "talib", ".", "RSI", "(", "self", ".", "close", ",", "n", ")", "if", "array", ":", "return", "result", "return", "result", "[", "-", "1", "]" ]

[ "RSI指标" ]

[ "def", "cidr_notation", "(", "ip_address", ",", "netmask", ")", ":", "try", ":", "inet_aton", "(", "ip_address", ")", "except", ":", "raise", "Exception", "(", "\"Invalid ip address '%s'\"", "%", "ip_address", ")", "try", ":", "inet_aton", "(", "netmask", ")", "except", ":", "raise", "Exception", "(", "\"Invalid netmask '%s'\"", "%", "netmask", ")", "ip_address_split", "=", "ip_address", ".", "split", "(", "'.'", ")", "netmask_split", "=", "netmask", ".", "split", "(", "'.'", ")", "# calculate network start", "net_start", "=", "[", "str", "(", "int", "(", "ip_address_split", "[", "x", "]", ")", "&", "int", "(", "netmask_split", "[", "x", "]", ")", ")", "for", "x", "in", "range", "(", "0", ",", "4", ")", "]", "return", "'.'", ".", "join", "(", "net_start", ")", "+", "'/'", "+", "get_net_size", "(", "netmask_split", ")" ]

[ "Retrieve", "the", "cidr", "notation", "given", "an", "ip", "address", "and", "netmask", ".", "For", "example", ":", "cidr_notation", "(", "12", ".", "34", ".", "56", ".", "78", "255", ".", "255", ".", "255", ".", "248", ")", "Would", "return", ":", "12", ".", "34", ".", "56", ".", "72", "/", "29" ]

[ "def", "subscribe_topics", "(", "self", ")", ":", "base", "=", "self", ".", "topic", "subscribe", "=", "self", ".", "mqtt", ".", "subscribe", "# device topics", "subscribe", "(", "b\"/\"", ".", "join", "(", "(", "base", ",", "b\"$stats/interval/set\"", ")", ")", ")", "subscribe", "(", "b\"/\"", ".", "join", "(", "(", "self", ".", "settings", ".", "MQTT_BASE_TOPIC", ",", "b\"$broadcast/#\"", ")", ")", ")", "# node topics", "nodes", "=", "self", ".", "nodes", "for", "node", "in", "nodes", ":", "for", "topic", "in", "node", ".", "subscribe", ":", "topic", "=", "b\"/\"", ".", "join", "(", "(", "base", ",", "topic", ")", ")", "# print('MQTT SUBSCRIBE: {}'.format(topic))", "subscribe", "(", "topic", ")", "self", ".", "topic_callbacks", "[", "topic", "]", "=", "node", ".", "callback" ]

[ "subscribe", "to", "all", "registered", "device", "and", "node", "topics" ]

[ "def", "stop", "(", "cls", ",", "app_id", ")", ":", "conn", "=", "Qubole", ".", "agent", "(", ")", "return", "conn", ".", "put", "(", "cls", ".", "element_path", "(", "app_id", ")", "+", "\"/stop\"", ")" ]

[ "Stops", "an", "app", "by", "issuing", "a", "PUT", "request", "to", "the", "/", "apps", "/", "ID", "/", "stop", "endpoint", "." ]

[ "def", "playlist_create", "(", "self", ",", "name", ",", "description", "=", "''", ",", "*", ",", "make_public", "=", "False", ",", "songs", "=", "None", ")", ":", "share_state", "=", "'PUBLIC'", "if", "make_public", "else", "'PRIVATE'", "playlist", "=", "self", ".", "_call", "(", "mc_calls", ".", "PlaylistsCreate", ",", "name", ",", "description", ",", "share_state", ")", ".", "body", "if", "songs", ":", "playlist", "=", "self", ".", "playlist_songs_add", "(", "songs", ",", "playlist", ")", "return", "playlist" ]

[ "Create", "a", "playlist", "." ]

[ "def", "loadfn", "(", "fn", ",", "*", "args", ",", "*", "*", "kwargs", ")", ":", "if", "\"mpk\"", "in", "os", ".", "path", ".", "basename", "(", "fn", ")", ".", "lower", "(", ")", ":", "if", "msgpack", "is", "None", ":", "raise", "RuntimeError", "(", "\"Loading of message pack files is not \"", "\"possible as msgpack-python is not installed.\"", ")", "if", "\"object_hook\"", "not", "in", "kwargs", ":", "kwargs", "[", "\"object_hook\"", "]", "=", "object_hook", "with", "zopen", "(", "fn", ",", "\"rb\"", ")", "as", "fp", ":", "return", "msgpack", ".", "load", "(", "fp", ",", "*", "args", ",", "*", "*", "kwargs", ")", "else", ":", "with", "zopen", "(", "fn", ")", "as", "fp", ":", "if", "\"yaml\"", "in", "os", ".", "path", ".", "basename", "(", "fn", ")", ".", "lower", "(", ")", ":", "if", "yaml", "is", "None", ":", "raise", "RuntimeError", "(", "\"Loading of YAML files is not \"", "\"possible as ruamel.yaml is not installed.\"", ")", "if", "\"Loader\"", "not", "in", "kwargs", ":", "kwargs", "[", "\"Loader\"", "]", "=", "Loader", "return", "yaml", ".", "load", "(", "fp", ",", "*", "args", ",", "*", "*", "kwargs", ")", "else", ":", "if", "\"cls\"", "not", "in", "kwargs", ":", "kwargs", "[", "\"cls\"", "]", "=", "MontyDecoder", "return", "json", ".", "load", "(", "fp", ",", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "Loads", "json", "/", "yaml", "/", "msgpack", "directly", "from", "a", "filename", "instead", "of", "a", "File", "-", "like", "object", ".", "For", "YAML", "ruamel", ".", "yaml", "must", "be", "installed", ".", "The", "file", "type", "is", "automatically", "detected", ".", "YAML", "is", "assumed", "if", "the", "filename", "contains", "yaml", "(", "lower", "or", "upper", "case", ")", ".", "Otherwise", "json", "is", "always", "assumed", "." ]

[ "def", "Update", "(", "self", ",", "env", ",", "args", "=", "None", ")", ":", "values", "=", "{", "}", "# first set the defaults:", "for", "option", "in", "self", ".", "options", ":", "if", "not", "option", ".", "default", "is", "None", ":", "values", "[", "option", ".", "key", "]", "=", "option", ".", "default", "# next set the value specified in the options file", "for", "filename", "in", "self", ".", "files", ":", "if", "os", ".", "path", ".", "exists", "(", "filename", ")", ":", "dir", "=", "os", ".", "path", ".", "split", "(", "os", ".", "path", ".", "abspath", "(", "filename", ")", ")", "[", "0", "]", "if", "dir", ":", "sys", ".", "path", ".", "insert", "(", "0", ",", "dir", ")", "try", ":", "values", "[", "'__name__'", "]", "=", "filename", "with", "open", "(", "filename", ",", "'r'", ")", "as", "f", ":", "contents", "=", "f", ".", "read", "(", ")", "exec", "(", "contents", ",", "{", "}", ",", "values", ")", "finally", ":", "if", "dir", ":", "del", "sys", ".", "path", "[", "0", "]", "del", "values", "[", "'__name__'", "]", "# set the values specified on the command line", "if", "args", "is", "None", ":", "args", "=", "self", ".", "args", "for", "arg", ",", "value", "in", "args", ".", "items", "(", ")", ":", "added", "=", "False", "for", "option", "in", "self", ".", "options", ":", "if", "arg", "in", "list", "(", "option", ".", "aliases", ")", "+", "[", "option", ".", "key", "]", ":", "values", "[", "option", ".", "key", "]", "=", "value", "added", "=", "True", "if", "not", "added", ":", "self", ".", "unknown", "[", "arg", "]", "=", "value", "# put the variables in the environment:", "# (don't copy over variables that are not declared as options)", "for", "option", "in", "self", ".", "options", ":", "try", ":", "env", "[", "option", ".", "key", "]", "=", "values", "[", "option", ".", "key", "]", "except", "KeyError", ":", "pass", "# Call the convert functions:", "for", "option", "in", "self", ".", "options", ":", "if", "option", ".", "converter", "and", "option", ".", "key", "in", "values", ":", "value", "=", "env", ".", "subst", "(", "'${%s}'", "%", "option", ".", "key", ")", "try", ":", "try", ":", "env", "[", "option", ".", "key", "]", "=", "option", ".", "converter", "(", "value", ")", "except", "TypeError", ":", "env", "[", "option", ".", "key", "]", "=", "option", ".", "converter", "(", "value", ",", "env", ")", "except", "ValueError", "as", "x", ":", "raise", "SCons", ".", "Errors", ".", "UserError", "(", "'Error converting option: %s\\n%s'", "%", "(", "option", ".", "key", ",", "x", ")", ")", "# Finally validate the values:", "for", "option", "in", "self", ".", "options", ":", "if", "option", ".", "validator", "and", "option", ".", "key", "in", "values", ":", "option", ".", "validator", "(", "option", ".", "key", ",", "env", ".", "subst", "(", "'${%s}'", "%", "option", ".", "key", ")", ",", "env", ")" ]

[ "Update", "an", "environment", "with", "the", "option", "variables", "." ]

[ "def", "Sonnad_Goudar_2006", "(", "Re", ",", "eD", ")", ":", "S", "=", "0.124", "*", "eD", "*", "Re", "+", "log", "(", "0.4587", "*", "Re", ")", "return", "(", ".8686", "*", "log", "(", ".4587", "*", "Re", "/", "S", "**", "(", "S", "/", "(", "S", "+", "1", ")", ")", ")", ")", "**", "-", "2" ]

[ "r", "Calculates", "Darcy", "friction", "factor", "using", "the", "method", "in", "Sonnad", "and", "Goudar", "(", "2006", ")", "[", "2", "]", "_", "as", "shown", "in", "[", "1", "]", "_", "." ]

[ "def", "build_image_from_inherited_image", "(", "self", ",", "image_name", ":", "str", ",", "image_tag", ":", "str", ",", "repo_path", ":", "Path", ",", "requirements_option", ":", "RequirementsOptions", ")", ":", "base_name", ",", "base_tag", "=", "self", ".", "get_inherit_image", "(", ")", "if", "requirements_option", "==", "RequirementsOptions", ".", "no_requirements", ":", "image", "=", "self", ".", "get_image", "(", "base_name", ",", "base_tag", ")", "image", ".", "tag", "(", "image_name", ",", "image_tag", ")", "# so ``build_image`` doesn't have to be called next time", "return", "image", "dockerfile", "=", "self", ".", "get_install_requirements_dockerfile", "(", "base_name", ",", "base_tag", ",", "repo_path", ",", "requirements_option", ")", "self", ".", "get_or_build_image", "(", "image_name", ",", "image_tag", ",", "dockerfile", ",", "build_context", "=", "repo_path", ".", "parent", ",", "pull", "=", "False", ")", "return", "self", ".", "get_image", "(", "image_name", ",", "image_tag", ")" ]

[ "Builds", "a", "image", "with", "installed", "requirements", "from", "the", "inherited", "image", ".", "(", "Or", "just", "tags", "the", "image", "if", "there", "are", "no", "requirements", ".", ")" ]

[ "def", "save_aggregate_report_to_elasticsearch", "(", "aggregate_report", ",", "index_suffix", "=", "None", ",", "monthly_indexes", "=", "False", ")", ":", "logger", ".", "debug", "(", "\"Saving aggregate report to Elasticsearch\"", ")", "aggregate_report", "=", "aggregate_report", ".", "copy", "(", ")", "metadata", "=", "aggregate_report", "[", "\"report_metadata\"", "]", "org_name", "=", "metadata", "[", "\"org_name\"", "]", "report_id", "=", "metadata", "[", "\"report_id\"", "]", "domain", "=", "aggregate_report", "[", "\"policy_published\"", "]", "[", "\"domain\"", "]", "begin_date", "=", "human_timestamp_to_datetime", "(", "metadata", "[", "\"begin_date\"", "]", ")", "end_date", "=", "human_timestamp_to_datetime", "(", "metadata", "[", "\"end_date\"", "]", ")", "begin_date_human", "=", "begin_date", ".", "strftime", "(", "\"%Y-%m-%d %H:%M:%S\"", ")", "end_date_human", "=", "end_date", ".", "strftime", "(", "\"%Y-%m-%d %H:%M:%S\"", ")", "if", "monthly_indexes", ":", "index_date", "=", "begin_date", ".", "strftime", "(", "\"%Y-%m\"", ")", "else", ":", "index_date", "=", "begin_date", ".", "strftime", "(", "\"%Y-%m-%d\"", ")", "aggregate_report", "[", "\"begin_date\"", "]", "=", "begin_date", "aggregate_report", "[", "\"end_date\"", "]", "=", "end_date", "date_range", "=", "[", "aggregate_report", "[", "\"begin_date\"", "]", ",", "aggregate_report", "[", "\"end_date\"", "]", "]", "org_name_query", "=", "Q", "(", "dict", "(", "match", "=", "dict", "(", "org_name", "=", "org_name", ")", ")", ")", "report_id_query", "=", "Q", "(", "dict", "(", "match", "=", "dict", "(", "report_id", "=", "report_id", ")", ")", ")", "domain_query", "=", "Q", "(", "dict", "(", "match", "=", "{", "\"published_policy.domain\"", ":", "domain", "}", ")", ")", "begin_date_query", "=", "Q", "(", "dict", "(", "match", "=", "dict", "(", "date_range", "=", "begin_date", ")", ")", ")", "end_date_query", "=", "Q", "(", "dict", "(", "match", "=", "dict", "(", "date_range", "=", "end_date", ")", ")", ")", "search", "=", "Search", "(", "index", "=", "\"dmarc_aggregate*\"", ")", "query", "=", "org_name_query", "&", "report_id_query", "&", "domain_query", "query", "=", "query", "&", "begin_date_query", "&", "end_date_query", "search", ".", "query", "=", "query", "existing", "=", "search", ".", "execute", "(", ")", "if", "len", "(", "existing", ")", ">", "0", ":", "raise", "AlreadySaved", "(", "\"An aggregate report ID {0} from {1} about {2} \"", "\"with a date range of {3} UTC to {4} UTC already \"", "\"exists in \"", "\"Elasticsearch\"", ".", "format", "(", "report_id", ",", "org_name", ",", "domain", ",", "begin_date_human", ",", "end_date_human", ")", ")", "published_policy", "=", "_PublishedPolicy", "(", "domain", "=", "aggregate_report", "[", "\"policy_published\"", "]", "[", "\"domain\"", "]", ",", "adkim", "=", "aggregate_report", "[", "\"policy_published\"", "]", "[", "\"adkim\"", "]", ",", "aspf", "=", "aggregate_report", "[", "\"policy_published\"", "]", "[", "\"aspf\"", "]", ",", "p", "=", "aggregate_report", "[", "\"policy_published\"", "]", "[", "\"p\"", "]", ",", "sp", "=", "aggregate_report", "[", "\"policy_published\"", "]", "[", "\"sp\"", "]", ",", "pct", "=", "aggregate_report", "[", "\"policy_published\"", "]", "[", "\"pct\"", "]", ",", "fo", "=", "aggregate_report", "[", "\"policy_published\"", "]", "[", "\"fo\"", "]", ")", "for", "record", "in", "aggregate_report", "[", "\"records\"", "]", ":", "agg_doc", "=", "_AggregateReportDoc", "(", "xml_schemea", "=", "aggregate_report", "[", "\"xml_schema\"", "]", ",", "org_name", "=", "metadata", "[", "\"org_name\"", "]", ",", "org_email", "=", "metadata", "[", "\"org_email\"", "]", ",", "org_extra_contact_info", "=", "metadata", "[", "\"org_extra_contact_info\"", "]", ",", "report_id", "=", "metadata", "[", "\"report_id\"", "]", ",", "date_range", "=", "date_range", ",", "errors", "=", "metadata", "[", "\"errors\"", "]", ",", "published_policy", "=", "published_policy", ",", "source_ip_address", "=", "record", "[", "\"source\"", "]", "[", "\"ip_address\"", "]", ",", "source_country", "=", "record", "[", "\"source\"", "]", "[", "\"country\"", "]", ",", "source_reverse_dns", "=", "record", "[", "\"source\"", "]", "[", "\"reverse_dns\"", "]", ",", "source_base_domain", "=", "record", "[", "\"source\"", "]", "[", "\"base_domain\"", "]", ",", "message_count", "=", "record", "[", "\"count\"", "]", ",", "disposition", "=", "record", "[", "\"policy_evaluated\"", "]", "[", "\"disposition\"", "]", ",", "dkim_aligned", "=", "record", "[", "\"policy_evaluated\"", "]", "[", "\"dkim\"", "]", "==", "\"pass\"", ",", "spf_aligned", "=", "record", "[", "\"policy_evaluated\"", "]", "[", "\"spf\"", "]", "==", "\"pass\"", ",", "header_from", "=", "record", "[", "\"identifiers\"", "]", "[", "\"header_from\"", "]", ",", "envelope_from", "=", "record", "[", "\"identifiers\"", "]", "[", "\"envelope_from\"", "]", ",", "envelope_to", "=", "record", "[", "\"identifiers\"", "]", "[", "\"envelope_to\"", "]", ")", "for", "override", "in", "record", "[", "\"policy_evaluated\"", "]", "[", "\"policy_override_reasons\"", "]", ":", "agg_doc", ".", "add_policy_override", "(", "type_", "=", "override", "[", "\"type\"", "]", ",", "comment", "=", "override", "[", "\"comment\"", "]", ")", "for", "dkim_result", "in", "record", "[", "\"auth_results\"", "]", "[", "\"dkim\"", "]", ":", "agg_doc", ".", "add_dkim_result", "(", "domain", "=", "dkim_result", "[", "\"domain\"", "]", ",", "selector", "=", "dkim_result", "[", "\"selector\"", "]", ",", "result", "=", "dkim_result", "[", "\"result\"", "]", ")", "for", "spf_result", "in", "record", "[", "\"auth_results\"", "]", "[", "\"spf\"", "]", ":", "agg_doc", ".", "add_spf_result", "(", "domain", "=", "spf_result", "[", "\"domain\"", "]", ",", "scope", "=", "spf_result", "[", "\"scope\"", "]", ",", "result", "=", "spf_result", "[", "\"result\"", "]", ")", "index", "=", "\"dmarc_aggregate\"", "if", "index_suffix", ":", "index", "=", "\"{0}_{1}\"", ".", "format", "(", "index", ",", "index_suffix", ")", "index", "=", "\"{0}-{1}\"", ".", "format", "(", "index", ",", "index_date", ")", "create_indexes", "(", "[", "index", "]", ")", "agg_doc", ".", "meta", ".", "index", "=", "index", "try", ":", "agg_doc", ".", "save", "(", ")", "except", "Exception", "as", "e", ":", "raise", "ElasticsearchError", "(", "\"Elasticsearch error: {0}\"", ".", "format", "(", "e", ".", "__str__", "(", ")", ")", ")" ]

[ "Saves", "a", "parsed", "DMARC", "aggregate", "report", "to", "ElasticSearch" ]

[ "def", "dictlist_convert_to_bool", "(", "dict_list", ":", "Iterable", "[", "Dict", "]", ",", "key", ":", "str", ")", "->", "None", ":", "for", "d", "in", "dict_list", ":", "# d[key] = True if d[key] == \"Y\" else False", "d", "[", "key", "]", "=", "1", "if", "d", "[", "key", "]", "==", "\"Y\"", "else", "0" ]

[ "Process", "an", "iterable", "of", "dictionaries", ".", "For", "each", "dictionary", "d", "convert", "(", "in", "place", ")", "d", "[", "key", "]", "to", "a", "bool", ".", "If", "that", "fails", "convert", "it", "to", "None", "." ]

[ "def", "_get_new_connection", "(", "self", ",", "conn_params", ")", ":", "self", ".", "__connection_string", "=", "conn_params", ".", "get", "(", "'connection_string'", ",", "''", ")", "conn", "=", "self", ".", "Database", ".", "connect", "(", "*", "*", "conn_params", ")", "return", "conn" ]

[ "Opens", "a", "connection", "to", "the", "database", "." ]

[ "def", "load", "(", "self", ")", ":", "pg", "=", "self", ".", "usr", ".", "getPage", "(", "\"http://www.neopets.com/bank.phtml\"", ")", "# Verifies account exists", "if", "not", "\"great to see you again\"", "in", "pg", ".", "content", ":", "logging", ".", "getLogger", "(", "\"neolib.user\"", ")", ".", "info", "(", "\"Could not load user's bank. Most likely does not have an account.\"", ",", "{", "'pg'", ":", "pg", "}", ")", "raise", "noBankAcct", "self", ".", "__loadDetails", "(", "pg", ")" ]

[ "Loads", "the", "user", "s", "account", "details", "and", "Raises", "parseException" ]

[ "def", "get_arctic_version", "(", "self", ",", "symbol", ",", "as_of", "=", "None", ")", ":", "return", "self", ".", "_read_metadata", "(", "symbol", ",", "as_of", "=", "as_of", ")", ".", "get", "(", "'arctic_version'", ",", "0", ")" ]

[ "Return", "the", "numerical", "representation", "of", "the", "arctic", "version", "used", "to", "write", "the", "last", "(", "or", "as_of", ")", "version", "for", "the", "given", "symbol", "." ]

[ "def", "space_cluster", "(", "catalog", ",", "d_thresh", ",", "show", "=", "True", ")", ":", "# Compute the distance matrix and linkage", "dist_mat", "=", "dist_mat_km", "(", "catalog", ")", "dist_vec", "=", "squareform", "(", "dist_mat", ")", "Z", "=", "linkage", "(", "dist_vec", ",", "method", "=", "'average'", ")", "# Cluster the linkage using the given threshold as the cutoff", "indices", "=", "fcluster", "(", "Z", ",", "t", "=", "d_thresh", ",", "criterion", "=", "'distance'", ")", "group_ids", "=", "list", "(", "set", "(", "indices", ")", ")", "indices", "=", "[", "(", "indices", "[", "i", "]", ",", "i", ")", "for", "i", "in", "range", "(", "len", "(", "indices", ")", ")", "]", "if", "show", ":", "# Plot the dendrogram...if it's not way too huge", "dendrogram", "(", "Z", ",", "color_threshold", "=", "d_thresh", ",", "distance_sort", "=", "'ascending'", ")", "plt", ".", "show", "(", ")", "# Sort by group id", "indices", ".", "sort", "(", "key", "=", "lambda", "tup", ":", "tup", "[", "0", "]", ")", "groups", "=", "[", "]", "for", "group_id", "in", "group_ids", ":", "group", "=", "Catalog", "(", ")", "for", "ind", "in", "indices", ":", "if", "ind", "[", "0", "]", "==", "group_id", ":", "group", ".", "append", "(", "catalog", "[", "ind", "[", "1", "]", "]", ")", "elif", "ind", "[", "0", "]", ">", "group_id", ":", "# Because we have sorted by group id, when the index is greater", "# than the group_id we can break the inner loop.", "# Patch applied by CJC 05/11/2015", "groups", ".", "append", "(", "group", ")", "break", "groups", ".", "append", "(", "group", ")", "return", "groups" ]

[ "Cluster", "a", "catalog", "by", "distance", "only", "." ]

[ "def", "is_valid_number_for_region", "(", "numobj", ",", "region_code", ")", ":", "country_code", "=", "numobj", ".", "country_code", "if", "region_code", "is", "None", ":", "return", "False", "metadata", "=", "PhoneMetadata", ".", "metadata_for_region_or_calling_code", "(", "country_code", ",", "region_code", ".", "upper", "(", ")", ")", "if", "(", "metadata", "is", "None", "or", "(", "region_code", "!=", "REGION_CODE_FOR_NON_GEO_ENTITY", "and", "country_code", "!=", "country_code_for_valid_region", "(", "region_code", ")", ")", ")", ":", "# Either the region code was invalid, or the country calling code for", "# this number does not match that of the region code.", "return", "False", "nsn", "=", "national_significant_number", "(", "numobj", ")", "return", "(", "_number_type_helper", "(", "nsn", ",", "metadata", ")", "!=", "PhoneNumberType", ".", "UNKNOWN", ")" ]

[ "Tests", "whether", "a", "phone", "number", "is", "valid", "for", "a", "certain", "region", "." ]

[ "def", "result", "(", "self", ")", ":", "if", "self", ".", "_result", ".", "lower", "(", ")", "==", "'w'", ":", "return", "WIN", "if", "self", ".", "_result", ".", "lower", "(", ")", "==", "'l'", "and", "self", ".", "overtime", "!=", "0", ":", "return", "OVERTIME_LOSS", "return", "LOSS" ]

[ "Returns", "a", "string", "constant", "to", "indicate", "whether", "the", "team", "lost", "in", "regulation", "lost", "in", "overtime", "or", "won", "." ]

[ "def", "_trunc", "(", "x", ",", "minval", "=", "None", ",", "maxval", "=", "None", ")", ":", "x", "=", "np", ".", "copy", "(", "x", ")", "if", "minval", "is", "not", "None", ":", "x", "[", "x", "<", "minval", "]", "=", "minval", "if", "maxval", "is", "not", "None", ":", "x", "[", "x", ">", "maxval", "]", "=", "maxval", "return", "x" ]

[ "Truncate", "vector", "values", "to", "have", "values", "on", "range", "[", "minval", "maxval", "]" ]

[ "def", "_get_task_with_policy", "(", "queue_name", ",", "task_id", ",", "owner", ")", ":", "now", "=", "datetime", ".", "datetime", ".", "utcnow", "(", ")", "task", "=", "(", "WorkQueue", ".", "query", ".", "filter_by", "(", "queue_name", "=", "queue_name", ",", "task_id", "=", "task_id", ")", ".", "with_lockmode", "(", "'update'", ")", ".", "first", "(", ")", ")", "if", "not", "task", ":", "raise", "TaskDoesNotExistError", "(", "'task_id=%r'", "%", "task_id", ")", "# Lease delta should be positive, meaning it has not yet expired!", "lease_delta", "=", "now", "-", "task", ".", "eta", "if", "lease_delta", ">", "datetime", ".", "timedelta", "(", "0", ")", ":", "db", ".", "session", ".", "rollback", "(", ")", "raise", "LeaseExpiredError", "(", "'queue=%r, task_id=%r expired %s'", "%", "(", "task", ".", "queue_name", ",", "task_id", ",", "lease_delta", ")", ")", "if", "task", ".", "last_owner", "!=", "owner", ":", "db", ".", "session", ".", "rollback", "(", ")", "raise", "NotOwnerError", "(", "'queue=%r, task_id=%r, owner=%r'", "%", "(", "task", ".", "queue_name", ",", "task_id", ",", "task", ".", "last_owner", ")", ")", "return", "task" ]

[ "Fetches", "the", "specified", "task", "and", "enforces", "ownership", "policy", "." ]

[ "def", "register_entity_to_group", "(", "self", ",", "entity", ",", "group", ")", ":", "if", "entity", "in", "self", ".", "_entities", ":", "if", "group", "in", "self", ".", "_groups", ":", "self", ".", "_groups", "[", "group", "]", ".", "append", "(", "entity", ")", "else", ":", "self", ".", "_groups", "[", "group", "]", "=", "[", "entity", "]", "else", ":", "raise", "UnmanagedEntityError", "(", "entity", ")" ]

[ "Add", "entity", "to", "a", "group", ".", "If", "group", "does", "not", "exist", "entity", "will", "be", "added", "as", "first", "member", "entity", "is", "of", "type", "Entity", "group", "is", "a", "string", "that", "is", "the", "name", "of", "the", "group" ]

[ "def", "get_gaf_format", "(", "self", ")", ":", "sep", "=", "'\\t'", "return", "sep", ".", "join", "(", "[", "self", ".", "gene", ",", "self", ".", "db_ref", ",", "self", ".", "term", ".", "id", ",", "self", ".", "evidence", ",", "'|'", ".", "join", "(", "self", ".", "db_ref", ")", ",", "'|'", ".", "join", "(", "self", ".", "with_", ")", "]", ")" ]

[ "Return", "a", "GAF", "2", ".", "0", "-", "compatible", "string", "representation", "of", "the", "annotation", "." ]

[ "def", "_translate_segment_glob", "(", "pattern", ")", ":", "# NOTE: This is derived from `fnmatch.translate()` and is similar to", "# the POSIX function `fnmatch()` with the `FNM_PATHNAME` flag set.", "escape", "=", "False", "regex", "=", "''", "i", ",", "end", "=", "0", ",", "len", "(", "pattern", ")", "while", "i", "<", "end", ":", "# Get next character.", "char", "=", "pattern", "[", "i", "]", "i", "+=", "1", "if", "escape", ":", "# Escape the character.", "escape", "=", "False", "regex", "+=", "re", ".", "escape", "(", "char", ")", "elif", "char", "==", "'\\\\'", ":", "# Escape character, escape next character.", "escape", "=", "True", "elif", "char", "==", "'*'", ":", "# Multi-character wildcard. Match any string (except slashes),", "# including an empty string.", "regex", "+=", "'[^/]*'", "elif", "char", "==", "'?'", ":", "# Single-character wildcard. Match any single character (except", "# a slash).", "regex", "+=", "'[^/]'", "elif", "char", "==", "'['", ":", "# Braket expression wildcard. Except for the beginning", "# exclamation mark, the whole braket expression can be used", "# directly as regex but we have to find where the expression", "# ends.", "# - \"[][!]\" matchs ']', '[' and '!'.", "# - \"[]-]\" matchs ']' and '-'.", "# - \"[!]a-]\" matchs any character except ']', 'a' and '-'.", "j", "=", "i", "# Pass brack expression negation.", "if", "j", "<", "end", "and", "pattern", "[", "j", "]", "==", "'!'", ":", "j", "+=", "1", "# Pass first closing braket if it is at the beginning of the", "# expression.", "if", "j", "<", "end", "and", "pattern", "[", "j", "]", "==", "']'", ":", "j", "+=", "1", "# Find closing braket. Stop once we reach the end or find it.", "while", "j", "<", "end", "and", "pattern", "[", "j", "]", "!=", "']'", ":", "j", "+=", "1", "if", "j", "<", "end", ":", "# Found end of braket expression. Increment j to be one past", "# the closing braket:", "#", "# [...]", "# ^ ^", "# i j", "#", "j", "+=", "1", "expr", "=", "'['", "if", "pattern", "[", "i", "]", "==", "'!'", ":", "# Braket expression needs to be negated.", "expr", "+=", "'^'", "i", "+=", "1", "elif", "pattern", "[", "i", "]", "==", "'^'", ":", "# POSIX declares that the regex braket expression negation", "# \"[^...]\" is undefined in a glob pattern. Python's", "# `fnmatch.translate()` escapes the caret ('^') as a", "# literal. To maintain consistency with undefined behavior,", "# I am escaping the '^' as well.", "expr", "+=", "'\\\\^'", "i", "+=", "1", "# Build regex braket expression. Escape slashes so they are", "# treated as literal slashes by regex as defined by POSIX.", "expr", "+=", "pattern", "[", "i", ":", "j", "]", ".", "replace", "(", "'\\\\'", ",", "'\\\\\\\\'", ")", "# Add regex braket expression to regex result.", "regex", "+=", "expr", "# Set i to one past the closing braket.", "i", "=", "j", "else", ":", "# Failed to find closing braket, treat opening braket as a", "# braket literal instead of as an expression.", "regex", "+=", "'\\\\['", "else", ":", "# Regular character, escape it for regex.", "regex", "+=", "re", ".", "escape", "(", "char", ")", "return", "regex" ]

[ "Translates", "the", "glob", "pattern", "to", "a", "regular", "expression", ".", "This", "is", "used", "in", "the", "constructor", "to", "translate", "a", "path", "segment", "glob", "pattern", "to", "its", "corresponding", "regular", "expression", "." ]

[ "def", "GET_names", "(", "self", ",", "path_info", ")", ":", "include_expired", "=", "False", "qs_values", "=", "path_info", "[", "'qs_values'", "]", "page", "=", "qs_values", ".", "get", "(", "'page'", ",", "None", ")", "if", "page", "is", "None", ":", "log", ".", "error", "(", "\"Page required\"", ")", "return", "self", ".", "_reply_json", "(", "{", "'error'", ":", "'page= argument required'", "}", ",", "status_code", "=", "400", ")", "try", ":", "page", "=", "int", "(", "page", ")", "if", "page", "<", "0", ":", "raise", "ValueError", "(", "\"Page is negative\"", ")", "except", "ValueError", ":", "log", ".", "error", "(", "\"Invalid page\"", ")", "return", "self", ".", "_reply_json", "(", "{", "'error'", ":", "'Invalid page= value'", "}", ",", "status_code", "=", "400", ")", "if", "qs_values", ".", "get", "(", "'all'", ",", "''", ")", ".", "lower", "(", ")", "in", "[", "'1'", ",", "'true'", "]", ":", "include_expired", "=", "True", "offset", "=", "page", "*", "100", "count", "=", "100", "blockstackd_url", "=", "get_blockstackd_url", "(", ")", "res", "=", "blockstackd_client", ".", "get_all_names", "(", "offset", ",", "count", ",", "include_expired", "=", "include_expired", ",", "hostport", "=", "blockstackd_url", ")", "if", "json_is_error", "(", "res", ")", ":", "log", ".", "error", "(", "\"Failed to list all names (offset={}, count={}): {}\"", ".", "format", "(", "offset", ",", "count", ",", "res", "[", "'error'", "]", ")", ")", "return", "self", ".", "_reply_json", "(", "{", "'error'", ":", "'Failed to list all names'", "}", ",", "status_code", "=", "res", ".", "get", "(", "'http_status'", ",", "502", ")", ")", "return", "self", ".", "_reply_json", "(", "res", ")" ]

[ "Get", "all", "names", "in", "existence", "If", "all", "=", "true", "is", "set", "then", "include", "expired", "names", ".", "Returns", "the", "list", "on", "success", "Returns", "400", "on", "invalid", "arguments", "Returns", "502", "on", "failure", "to", "get", "names" ]

[ "def", "_has_population_germline", "(", "rec", ")", ":", "for", "k", "in", "population_keys", ":", "if", "k", "in", "rec", ".", "header", ".", "info", ":", "return", "True", "return", "False" ]

[ "Check", "if", "header", "defines", "population", "annotated", "germline", "samples", "for", "tumor", "only", "." ]

[ "def", "printSegmentForCell", "(", "tm", ",", "cell", ")", ":", "print", "\"Segments for cell\"", ",", "cell", ",", "\":\"", "for", "seg", "in", "tm", ".", "basalConnections", ".", "_cells", "[", "cell", "]", ".", "_segments", ":", "print", "\" \"", ",", "synapses", "=", "seg", ".", "_synapses", "for", "s", "in", "synapses", ":", "print", "\"%d:%g\"", "%", "(", "s", ".", "presynapticCell", ",", "s", ".", "permanence", ")", ",", "print" ]

[ "Print", "segment", "information", "for", "this", "cell" ]

[ "def", "read", "(", "self", ",", "want", "=", "0", ")", ":", "if", "self", ".", "_finished", ":", "if", "self", ".", "_finished", "==", "1", ":", "self", ".", "_finished", "+=", "1", "return", "\"\"", "return", "EOFError", "(", "\"EOF reached\"", ")", "# Thread communication", "self", ".", "_want", "=", "want", "self", ".", "_add", ".", "set", "(", ")", "self", ".", "_result", ".", "wait", "(", ")", "self", ".", "_result", ".", "clear", "(", ")", "if", "want", ":", "data", "=", "self", ".", "_data", "[", ":", "want", "]", "self", ".", "_data", "=", "self", ".", "_data", "[", "want", ":", "]", "else", ":", "data", "=", "self", ".", "_data", "self", ".", "_data", "=", "bytes", "(", ")", "return", "data" ]

[ "Read", "method", "gets", "data", "from", "internal", "buffer", "while", "releasing", ":", "meth", ":", "write", "locks", "when", "needed", "." ]

[ "def", "get_serializer", "(", "name", ")", ":", "try", ":", "log", ".", "debug", "(", "'Using %s as serializer'", ",", "name", ")", "return", "SERIALIZER_LOOKUP", "[", "name", "]", "except", "KeyError", ":", "msg", "=", "'Serializer {} is not available'", ".", "format", "(", "name", ")", "log", ".", "error", "(", "msg", ",", "exc_info", "=", "True", ")", "raise", "InvalidSerializerException", "(", "msg", ")" ]

[ "Return", "the", "serialize", "function", "." ]

[ "def", "_shrink_file", "(", "dicom_file_in", ",", "subsample_factor", ")", ":", "# Default meta_fields", "# Required fields according to reference", "dicom_file_out", "=", "dicom_file_in", "# Load dicom_file_in", "dicom_in", "=", "compressed_dicom", ".", "read_file", "(", "dicom_file_in", ")", "# Create new dicom file", "# Set new file meta information", "file_meta", "=", "pydicom", ".", "dataset", ".", "Dataset", "(", ")", "for", "key", ",", "value", "in", "dicom_in", ".", "file_meta", ".", "items", "(", ")", ":", "file_meta", ".", "add", "(", "value", ")", "# Create the FileDataset instance (initially no data elements, but file_meta supplied)", "dicom_out", "=", "pydicom", ".", "dataset", ".", "FileDataset", "(", "dicom_file_out", ",", "{", "}", ",", "file_meta", "=", "file_meta", ",", "preamble", "=", "b'\\0'", "*", "128", ")", "# Copy transfer syntax", "dicom_out", ".", "is_little_endian", "=", "dicom_in", ".", "is_little_endian", "dicom_out", ".", "is_implicit_VR", "=", "dicom_in", ".", "is_implicit_VR", "rows", "=", "0", "columns", "=", "0", "# Add the data elements", "for", "field_key", ",", "field_value", "in", "dicom_in", ".", "items", "(", ")", ":", "logging", ".", "info", "(", "field_key", ")", "if", "field_key", "==", "(", "0x7fe0", ",", "0x0010", ")", ":", "pixel_array", "=", "dicom_in", ".", "pixel_array", "[", ":", ":", "subsample_factor", ",", ":", ":", "subsample_factor", "]", "dicom_out", ".", "PixelData", "=", "pixel_array", ".", "tostring", "(", ")", "# = byte array (see pydicom docs)", "rows", "=", "pixel_array", ".", "shape", "[", "1", "]", "columns", "=", "pixel_array", ".", "shape", "[", "0", "]", "# noinspection PyPep8Naming", "dicom_out", "[", "0x7fe0", ",", "0x0010", "]", ".", "VR", "=", "'OB'", "else", ":", "dicom_out", ".", "add", "(", "field_value", ")", "dicom_out", ".", "PixelSpacing", "[", "0", "]", "*=", "subsample_factor", "dicom_out", ".", "PixelSpacing", "[", "1", "]", "*=", "subsample_factor", "dicom_out", ".", "Rows", "=", "rows", "dicom_out", ".", "Columns", "=", "columns", "# Save dicom_file_out", "# Make sure we have a directory", "if", "not", "os", ".", "path", ".", "exists", "(", "os", ".", "path", ".", "dirname", "(", "dicom_file_out", ")", ")", ":", "logging", ".", "info", "(", "'Decompressing files'", ")", "# Save the file", "dicom_out", ".", "save_as", "(", "dicom_file_out", ",", "write_like_original", "=", "False", ")" ]

[ "Anonimize", "a", "single", "dicomfile", ":", "param", "dicom_file_in", ":", "filepath", "for", "input", "file", ":", "param", "dicom_file_out", ":", "filepath", "for", "output", "file", ":", "param", "fields_to_keep", ":", "dicom", "tags", "to", "keep" ]

[ "def", "_build_urlmapping", "(", "urls", ",", "strict_slashes", "=", "False", ",", "*", "*", "kwargs", ")", ":", "rules", "=", "_build_rules", "(", "urls", ")", "return", "Map", "(", "rules", "=", "list", "(", "rules", ")", ",", "strict_slashes", "=", "strict_slashes", ",", "*", "*", "kwargs", ")" ]

[ "Convers", "the", "anillo", "urlmappings", "list", "into", "werkzeug", "Map", "instance", "." ]

[ "def", "_deserialize_datetime", "(", "self", ",", "data", ")", ":", "for", "key", "in", "data", ":", "if", "isinstance", "(", "data", "[", "key", "]", ",", "dict", ")", ":", "if", "data", "[", "key", "]", ".", "get", "(", "'type'", ")", "==", "'datetime'", ":", "data", "[", "key", "]", "=", "datetime", ".", "datetime", ".", "fromtimestamp", "(", "data", "[", "key", "]", "[", "'value'", "]", ")", "return", "data" ]

[ "Take", "any", "values", "coming", "in", "as", "a", "datetime", "and", "deserialize", "them" ]

[ "def", "login", "(", "self", ",", "token", ",", "use_token", "=", "True", ",", "mount_point", "=", "DEFAULT_MOUNT_POINT", ")", ":", "params", "=", "{", "'token'", ":", "token", ",", "}", "api_path", "=", "'/v1/auth/{mount_point}/login'", ".", "format", "(", "mount_point", "=", "mount_point", ")", "return", "self", ".", "_adapter", ".", "login", "(", "url", "=", "api_path", ",", "use_token", "=", "use_token", ",", "json", "=", "params", ",", ")" ]

[ "Login", "using", "GitHub", "access", "token", "." ]

[ "def", "_on_changed", "(", "self", ")", ":", "page", "=", "self", ".", "_get_page", "(", ")", "if", "not", "page", ".", "flag_autosave", ":", "page", ".", "flag_changed", "=", "True", "self", ".", "_update_gui_text_tabs", "(", ")" ]

[ "Slot", "for", "changed", "events" ]

[ "def", "date_parser", "(", "items", ")", ":", "try", ":", "dt", "=", "datetime", ".", "strptime", "(", "items", ",", "\"%d/%m/%Y %H:%M:%S\"", ")", "except", "Exception", "as", "e", ":", "try", ":", "dt", "=", "datetime", ".", "strptime", "(", "items", ",", "\"%m/%d/%Y %H:%M:%S\"", ")", "except", "Exception", "as", "ee", ":", "raise", "Exception", "(", "\"error parsing datetime string\"", "+", "\" {0}: \\n{1}\\n{2}\"", ".", "format", "(", "str", "(", "items", ")", ",", "str", "(", "e", ")", ",", "str", "(", "ee", ")", ")", ")", "return", "dt" ]

[ "datetime", "parser", "to", "help", "load", "smp", "files" ]

[ "def", "_send_content", "(", "self", ",", "content", ",", "connection", ")", ":", "if", "connection", ":", "if", "connection", ".", "async", ":", "callback", "=", "connection", ".", "callbacks", "[", "'remote'", "]", "if", "callback", ":", "callback", "(", "self", ",", "self", ".", "parent_object", ",", "content", ")", "self", ".", "current_connection", ".", "reset", "(", ")", "self", ".", "current_connection", "=", "None", "else", ":", "return", "(", "self", ",", "self", ".", "parent_object", ",", "content", ")" ]

[ "Send", "a", "content", "array", "from", "the", "connection" ]

[ "def", "p_new_expr", "(", "self", ",", "p", ")", ":", "if", "len", "(", "p", ")", "==", "2", ":", "p", "[", "0", "]", "=", "p", "[", "1", "]", "else", ":", "p", "[", "0", "]", "=", "self", ".", "asttypes", ".", "NewExpr", "(", "p", "[", "2", "]", ")", "p", "[", "0", "]", ".", "setpos", "(", "p", ")" ]

[ "new_expr", ":", "member_expr", "|", "NEW", "new_expr" ]

[ "def", "map_nested", "(", "function", ",", "data_struct", ",", "dict_only", "=", "False", ",", "map_tuple", "=", "False", ")", ":", "# Could add support for more exotic data_struct, like OrderedDict", "if", "isinstance", "(", "data_struct", ",", "dict", ")", ":", "return", "{", "k", ":", "map_nested", "(", "function", ",", "v", ",", "dict_only", ",", "map_tuple", ")", "for", "k", ",", "v", "in", "data_struct", ".", "items", "(", ")", "}", "elif", "not", "dict_only", ":", "types", "=", "[", "list", "]", "if", "map_tuple", ":", "types", ".", "append", "(", "tuple", ")", "if", "isinstance", "(", "data_struct", ",", "tuple", "(", "types", ")", ")", ":", "mapped", "=", "[", "map_nested", "(", "function", ",", "v", ",", "dict_only", ",", "map_tuple", ")", "for", "v", "in", "data_struct", "]", "if", "isinstance", "(", "data_struct", ",", "list", ")", ":", "return", "mapped", "else", ":", "return", "tuple", "(", "mapped", ")", "# Singleton", "return", "function", "(", "data_struct", ")" ]

[ "Apply", "a", "function", "recursively", "to", "each", "element", "of", "a", "nested", "data", "struct", "." ]

[ "def", "setup", "(", "self", ")", ":", "self", ".", "devman", ".", "sort_device", "(", ")", "self", ".", "call", ".", "setup", "(", ")", "self", ".", "model_setup", "(", ")", "self", ".", "xy_addr0", "(", ")", "self", ".", "dae", ".", "setup", "(", ")", "self", ".", "to_sysbase", "(", ")", "return", "self" ]

[ "Set", "up", "the", "power", "system", "object", "by", "executing", "the", "following", "workflow", ":" ]

[ "def", "parse_reports", "(", "self", ")", ":", "# Set up vars", "self", ".", "infer_exp", "=", "dict", "(", ")", "regexes", "=", "{", "'pe_sense'", ":", "r\"\\\"1\\+\\+,1--,2\\+-,2-\\+\\\": (\\d\\.\\d+)\"", ",", "'pe_antisense'", ":", "r\"\\\"1\\+-,1-\\+,2\\+\\+,2--\\\": (\\d\\.\\d+)\"", ",", "'se_sense'", ":", "r\"\\\"\\+\\+,--\\\": (\\d\\.\\d+)\"", ",", "'se_antisense'", ":", "r\"\\+-,-\\+\\\": (\\d\\.\\d+)\"", ",", "'failed'", ":", "r\"Fraction of reads failed to determine: (\\d\\.\\d+)\"", "}", "# Go through files and parse data using regexes", "for", "f", "in", "self", ".", "find_log_files", "(", "'rseqc/infer_experiment'", ")", ":", "d", "=", "dict", "(", ")", "for", "k", ",", "r", "in", "regexes", ".", "items", "(", ")", ":", "r_search", "=", "re", ".", "search", "(", "r", ",", "f", "[", "'f'", "]", ",", "re", ".", "MULTILINE", ")", "if", "r_search", ":", "d", "[", "k", "]", "=", "float", "(", "r_search", ".", "group", "(", "1", ")", ")", "if", "len", "(", "d", ")", ">", "0", ":", "if", "f", "[", "'s_name'", "]", "in", "self", ".", "infer_exp", ":", "log", ".", "debug", "(", "\"Duplicate sample name found! Overwriting: {}\"", ".", "format", "(", "f", "[", "'s_name'", "]", ")", ")", "self", ".", "add_data_source", "(", "f", ",", "section", "=", "'infer_experiment'", ")", "self", ".", "infer_exp", "[", "f", "[", "'s_name'", "]", "]", "=", "d", "# Filter to strip out ignored sample names", "self", ".", "infer_exp", "=", "self", ".", "ignore_samples", "(", "self", ".", "infer_exp", ")", "if", "len", "(", "self", ".", "infer_exp", ")", ">", "0", ":", "# Write to file", "self", ".", "write_data_file", "(", "self", ".", "infer_exp", ",", "'multiqc_rseqc_infer_experiment'", ")", "# Merge PE and SE for plot", "pdata", "=", "dict", "(", ")", "for", "s_name", ",", "vals", "in", "self", ".", "infer_exp", ".", "items", "(", ")", ":", "pdata", "[", "s_name", "]", "=", "dict", "(", ")", "for", "k", ",", "v", "in", "vals", ".", "items", "(", ")", ":", "v", "*=", "100.0", "# Multiply to get percentage", "if", "k", "[", ":", "2", "]", "==", "'pe'", "or", "k", "[", ":", "2", "]", "==", "'se'", ":", "k", "=", "k", "[", "3", ":", "]", "pdata", "[", "s_name", "]", "[", "k", "]", "=", "v", "+", "pdata", "[", "s_name", "]", ".", "get", "(", "k", ",", "0", ")", "# Plot bar graph of groups", "keys", "=", "OrderedDict", "(", ")", "keys", "[", "'sense'", "]", "=", "{", "'name'", ":", "\"Sense\"", "}", "keys", "[", "'antisense'", "]", "=", "{", "'name'", ":", "\"Antisense\"", "}", "keys", "[", "'failed'", "]", "=", "{", "'name'", ":", "\"Undetermined\"", "}", "# Config for the plot", "pconfig", "=", "{", "'id'", ":", "'rseqc_infer_experiment_plot'", ",", "'title'", ":", "'RSeQC: Infer experiment'", ",", "'ylab'", ":", "'% Tags'", ",", "'ymin'", ":", "0", ",", "'ymax'", ":", "100", ",", "'tt_percentages'", ":", "False", ",", "'ylab_format'", ":", "'{value}%'", ",", "'cpswitch'", ":", "False", "}", "self", ".", "add_section", "(", "name", "=", "'Infer experiment'", ",", "anchor", "=", "'rseqc-infer_experiment'", ",", "description", "=", "'<a href=\"http://rseqc.sourceforge.net/#infer-experiment-py\" target=\"_blank\">Infer experiment</a>'", "\" counts the percentage of reads and read pairs that match the strandedness of overlapping transcripts.\"", "\" It can be used to infer whether RNA-seq library preps are stranded (sense or antisense).\"", ",", "plot", "=", "bargraph", ".", "plot", "(", "pdata", ",", "keys", ",", "pconfig", ")", ")", "# Return number of samples found", "return", "len", "(", "self", ".", "infer_exp", ")" ]

[ "Find", "RSeQC", "infer_experiment", "reports", "and", "parse", "their", "data" ]

[ "def", "cert_from_instance", "(", "instance", ")", ":", "if", "instance", ".", "signature", ":", "if", "instance", ".", "signature", ".", "key_info", ":", "return", "cert_from_key_info", "(", "instance", ".", "signature", ".", "key_info", ",", "ignore_age", "=", "True", ")", "return", "[", "]" ]

[ "Find", "certificates", "that", "are", "part", "of", "an", "instance" ]

[ "def", "_decode_image", "(", "fobj", ",", "session", ",", "filename", ")", ":", "buf", "=", "fobj", ".", "read", "(", ")", "image", "=", "tfds", ".", "core", ".", "lazy_imports", ".", "cv2", ".", "imdecode", "(", "np", ".", "fromstring", "(", "buf", ",", "dtype", "=", "np", ".", "uint8", ")", ",", "flags", "=", "3", ")", "# Note: Converts to RGB.", "if", "image", "is", "None", ":", "logging", ".", "warning", "(", "\"Image %s could not be decoded by OpenCV, falling back to TF\"", ",", "filename", ")", "try", ":", "image", "=", "tf", ".", "image", ".", "decode_image", "(", "buf", ",", "channels", "=", "3", ")", "image", "=", "session", ".", "run", "(", "image", ")", "except", "tf", ".", "errors", ".", "InvalidArgumentError", ":", "logging", ".", "fatal", "(", "\"Image %s could not be decoded by Tensorflow\"", ",", "filename", ")", "# The GIF images contain a single frame.", "if", "len", "(", "image", ".", "shape", ")", "==", "4", ":", "# rank=4 -> rank=3", "image", "=", "image", ".", "reshape", "(", "image", ".", "shape", "[", "1", ":", "]", ")", "return", "image" ]

[ "Reads", "and", "decodes", "an", "image", "from", "a", "file", "object", "as", "a", "Numpy", "array", "." ]

[ "def", "scopes", "(", "self", ")", ":", "if", "not", "self", ".", "__scopes", ":", "self", ".", "__scopes", "=", "Scopes", "(", "self", ".", "__connection", ")", "return", "self", ".", "__scopes" ]

[ "Gets", "the", "Scopes", "API", "client", "." ]

[ "def", "add_default_parameter_values", "(", "self", ",", "sam_template", ")", ":", "parameter_definition", "=", "sam_template", ".", "get", "(", "\"Parameters\"", ",", "None", ")", "if", "not", "parameter_definition", "or", "not", "isinstance", "(", "parameter_definition", ",", "dict", ")", ":", "return", "self", ".", "parameter_values", "for", "param_name", ",", "value", "in", "parameter_definition", ".", "items", "(", ")", ":", "if", "param_name", "not", "in", "self", ".", "parameter_values", "and", "isinstance", "(", "value", ",", "dict", ")", "and", "\"Default\"", "in", "value", ":", "self", ".", "parameter_values", "[", "param_name", "]", "=", "value", "[", "\"Default\"", "]" ]

[ "Method", "to", "read", "default", "values", "for", "template", "parameters", "and", "merge", "with", "user", "supplied", "values", "." ]