Datasets:

---

kejian

/

codesearchnet-python-raw

like 1

[ "def", "parse_table_definition_file", "(", "file", ")", ":", "logging", ".", "info", "(", "\"Reading table definition from '%s'...\"", ",", "file", ")", "if", "not", "os", ".", "path", ".", "isfile", "(", "file", ")", ":", "logging", ".", "error", "(", "\"File '%s' does not exist.\"", ",", "file", ")", "exit", "(", "1", ")", "try", ":", "tableGenFile", "=", "ElementTree", ".", "ElementTree", "(", ")", ".", "parse", "(", "file", ")", "except", "IOError", "as", "e", ":", "logging", ".", "error", "(", "'Could not read result file %s: %s'", ",", "file", ",", "e", ")", "exit", "(", "1", ")", "except", "ElementTree", ".", "ParseError", "as", "e", ":", "logging", ".", "error", "(", "'Table file %s is invalid: %s'", ",", "file", ",", "e", ")", "exit", "(", "1", ")", "if", "'table'", "!=", "tableGenFile", ".", "tag", ":", "logging", ".", "error", "(", "\"Table file %s is invalid: It's root element is not named 'table'.\"", ",", "file", ")", "exit", "(", "1", ")", "return", "tableGenFile" ]

[ "Read", "an", "parse", "the", "XML", "of", "a", "table", "-", "definition", "file", "." ]

[ "def", "begin_state", "(", "self", ",", "func", "=", "symbol", ".", "zeros", ",", "*", "*", "kwargs", ")", ":", "assert", "not", "self", ".", "_modified", ",", "\"After applying modifier cells (e.g. DropoutCell) the base \"", "\"cell cannot be called directly. Call the modifier cell instead.\"", "states", "=", "[", "]", "for", "info", "in", "self", ".", "state_info", ":", "self", ".", "_init_counter", "+=", "1", "if", "info", "is", "None", ":", "state", "=", "func", "(", "name", "=", "'%sbegin_state_%d'", "%", "(", "self", ".", "_prefix", ",", "self", ".", "_init_counter", ")", ",", "*", "*", "kwargs", ")", "else", ":", "kwargs", ".", "update", "(", "info", ")", "state", "=", "func", "(", "name", "=", "'%sbegin_state_%d'", "%", "(", "self", ".", "_prefix", ",", "self", ".", "_init_counter", ")", ",", "*", "*", "kwargs", ")", "states", ".", "append", "(", "state", ")", "return", "states" ]

[ "Initial", "state", "for", "this", "cell", "." ]

[ "def", "start_new_hypervisor", "(", "self", ",", "working_dir", "=", "None", ")", ":", "if", "not", "self", ".", "_dynamips_path", ":", "self", ".", "find_dynamips", "(", ")", "if", "not", "working_dir", ":", "working_dir", "=", "tempfile", ".", "gettempdir", "(", ")", "# FIXME: hypervisor should always listen to 127.0.0.1", "# See https://github.com/GNS3/dynamips/issues/62", "server_config", "=", "self", ".", "config", ".", "get_section_config", "(", "\"Server\"", ")", "server_host", "=", "server_config", ".", "get", "(", "\"host\"", ")", "try", ":", "info", "=", "socket", ".", "getaddrinfo", "(", "server_host", ",", "0", ",", "socket", ".", "AF_UNSPEC", ",", "socket", ".", "SOCK_STREAM", ",", "0", ",", "socket", ".", "AI_PASSIVE", ")", "if", "not", "info", ":", "raise", "DynamipsError", "(", "\"getaddrinfo returns an empty list on {}\"", ".", "format", "(", "server_host", ")", ")", "for", "res", "in", "info", ":", "af", ",", "socktype", ",", "proto", ",", "_", ",", "sa", "=", "res", "# let the OS find an unused port for the Dynamips hypervisor", "with", "socket", ".", "socket", "(", "af", ",", "socktype", ",", "proto", ")", "as", "sock", ":", "sock", ".", "bind", "(", "sa", ")", "port", "=", "sock", ".", "getsockname", "(", ")", "[", "1", "]", "break", "except", "OSError", "as", "e", ":", "raise", "DynamipsError", "(", "\"Could not find free port for the Dynamips hypervisor: {}\"", ".", "format", "(", "e", ")", ")", "port_manager", "=", "PortManager", ".", "instance", "(", ")", "hypervisor", "=", "Hypervisor", "(", "self", ".", "_dynamips_path", ",", "working_dir", ",", "server_host", ",", "port", ",", "port_manager", ".", "console_host", ")", "log", ".", "info", "(", "\"Creating new hypervisor {}:{} with working directory {}\"", ".", "format", "(", "hypervisor", ".", "host", ",", "hypervisor", ".", "port", ",", "working_dir", ")", ")", "yield", "from", "hypervisor", ".", "start", "(", ")", "log", ".", "info", "(", "\"Hypervisor {}:{} has successfully started\"", ".", "format", "(", "hypervisor", ".", "host", ",", "hypervisor", ".", "port", ")", ")", "yield", "from", "hypervisor", ".", "connect", "(", ")", "if", "parse_version", "(", "hypervisor", ".", "version", ")", "<", "parse_version", "(", "'0.2.11'", ")", ":", "raise", "DynamipsError", "(", "\"Dynamips version must be >= 0.2.11, detected version is {}\"", ".", "format", "(", "hypervisor", ".", "version", ")", ")", "return", "hypervisor" ]

[ "Creates", "a", "new", "Dynamips", "process", "and", "start", "it", "." ]

[ "def", "auto_rewrite_input", "(", "self", ",", "cmd", ")", ":", "if", "not", "self", ".", "show_rewritten_input", ":", "return", "rw", "=", "self", ".", "prompt_manager", ".", "render", "(", "'rewrite'", ")", "+", "cmd", "try", ":", "# plain ascii works better w/ pyreadline, on some machines, so", "# we use it and only print uncolored rewrite if we have unicode", "rw", "=", "str", "(", "rw", ")", "print", ">>", "io", ".", "stdout", ",", "rw", "except", "UnicodeEncodeError", ":", "print", "\"------> \"", "+", "cmd" ]

[ "Print", "to", "the", "screen", "the", "rewritten", "form", "of", "the", "user", "s", "command", "." ]

[ "def", "_X509__asn1date_to_datetime", "(", "asn1date", ")", ":", "bio", "=", "Membio", "(", ")", "libcrypto", ".", "ASN1_TIME_print", "(", "bio", ".", "bio", ",", "asn1date", ")", "pydate", "=", "datetime", ".", "strptime", "(", "str", "(", "bio", ")", ",", "\"%b %d %H:%M:%S %Y %Z\"", ")", "return", "pydate", ".", "replace", "(", "tzinfo", "=", "utc", ")" ]

[ "Converts", "openssl", "ASN1_TIME", "object", "to", "python", "datetime", ".", "datetime" ]

[ "def", "get", "(", "self", ",", "eid", ")", ":", "data", "=", "self", ".", "_http_req", "(", "'connections/%u'", "%", "eid", ")", "self", ".", "debug", "(", "0x01", ",", "data", "[", "'decoded'", "]", ")", "return", "data", "[", "'decoded'", "]" ]

[ "Returns", "a", "dict", "with", "the", "complete", "record", "of", "the", "entity", "with", "the", "given", "eID" ]

[ "def", "get_tree_from_initramfs", "(", "root", "=", "None", ")", ":", "from", "insights", "import", "run", "return", "run", "(", "MultipathConfTreeInitramfs", ",", "root", "=", "root", ")", ".", "get", "(", "MultipathConfTreeInitramfs", ")" ]

[ "This", "is", "a", "helper", "function", "to", "get", "a", "multipath", "configuration", "(", "from", "initramfs", "image", ")", "component", "for", "your", "local", "machine", "or", "an", "archive", ".", "It", "s", "for", "use", "in", "interactive", "sessions", "." ]

[ "def", "delete_custom_field", "(", "self", ",", "custom_field_key", ")", ":", "custom_field_key", "=", "quote", "(", "custom_field_key", ",", "''", ")", "response", "=", "self", ".", "_delete", "(", "\"/lists/%s/customfields/%s.json\"", "%", "(", "self", ".", "list_id", ",", "custom_field_key", ")", ")" ]

[ "Deletes", "a", "custom", "field", "associated", "with", "this", "list", "." ]

[ "def", "locator", "(", "self", ",", "value", ")", ":", "self", ".", "_locator", "=", "value", "self", ".", "_latitude", ",", "self", ".", "_longitude", "=", "utils", ".", "from_grid_locator", "(", "value", ")" ]

[ "Update", "the", "locator", "and", "trigger", "a", "latitude", "and", "longitude", "update", "." ]

[ "def", "_valid_directory", "(", "self", ",", "path", ")", ":", "abspath", "=", "os", ".", "path", ".", "abspath", "(", "path", ")", "if", "not", "os", ".", "path", ".", "isdir", "(", "abspath", ")", ":", "raise", "argparse", ".", "ArgumentTypeError", "(", "'Not a valid directory: {}'", ".", "format", "(", "abspath", ")", ")", "return", "abspath" ]

[ "Ensure", "that", "the", "given", "path", "is", "valid", "." ]

[ "def", "listdir", "(", "p", ",", "match", "=", "'*'", ",", "exclude", "=", "''", ",", "listtype", "=", "'file'", ",", "matchfun", "=", "None", ")", ":", "if", "listtype", "==", "'file'", ":", "gen", "=", "listfile", "(", "p", ")", "elif", "listtype", "==", "'filepath'", ":", "gen", "=", "listfilepath", "(", "p", ")", "elif", "listtype", "==", "'dir'", ":", "gen", "=", "listfolder", "(", "p", ")", "elif", "listtype", "==", "'dirpath'", ":", "gen", "=", "listfolderpath", "(", "p", ")", "else", ":", "# list file or folder", "gen", "=", "(", "entry", ".", "name", "for", "entry", "in", "scandir", ".", "scandir", "(", "p", ")", ")", "return", "filter_pattern", "(", "gen", ",", "match", ",", "exclude", ",", "matchfun", ")" ]

[ "list", "file", "(", "or", "folder", ")", "for", "this", "path", "(", "NOT", "recursive", ")", ":", "param", "p", ":", ":", "param", "match", ":", ":", "param", "exclude", ":", ":", "param", "listtype", ":", "(", "file", "|", "filepath", "|", "dir", "|", "all", ")", ":", "param", "matchfun", ":", "match", "fun", "(", "default", "fnmatch", ".", "fnmatch", ")", "True", "/", "False", "=", "matchfun", "(", "name", "pattern", ")", ":", "rtype", ":" ]

[ "def", "get_index_fields", "(", "self", ")", ":", "index_fields", "=", "self", ".", "get_meta_option", "(", "'index'", ",", "[", "]", ")", "if", "index_fields", ":", "return", "index_fields", "model", "=", "getattr", "(", "self", ".", "model_serializer_meta", ",", "'model'", ",", "None", ")", "if", "model", ":", "pk_name", "=", "model", ".", "_meta", ".", "pk", ".", "name", "if", "pk_name", "in", "self", ".", "child", ".", "get_fields", "(", ")", ":", "return", "[", "pk_name", "]", "return", "[", "]" ]

[ "List", "of", "fields", "to", "use", "for", "index" ]

[ "def", "get_embedding_weights_from_file", "(", "word_dict", ",", "file_path", ",", "ignore_case", "=", "False", ")", ":", "pre_trained", "=", "{", "}", "with", "codecs", ".", "open", "(", "file_path", ",", "'r'", ",", "'utf8'", ")", "as", "reader", ":", "for", "line", "in", "reader", ":", "line", "=", "line", ".", "strip", "(", ")", "if", "not", "line", ":", "continue", "parts", "=", "line", ".", "split", "(", ")", "if", "ignore_case", ":", "parts", "[", "0", "]", "=", "parts", "[", "0", "]", ".", "lower", "(", ")", "pre_trained", "[", "parts", "[", "0", "]", "]", "=", "list", "(", "map", "(", "float", ",", "parts", "[", "1", ":", "]", ")", ")", "embd_dim", "=", "len", "(", "next", "(", "iter", "(", "pre_trained", ".", "values", "(", ")", ")", ")", ")", "weights", "=", "[", "[", "0.0", "]", "*", "embd_dim", "for", "_", "in", "range", "(", "max", "(", "word_dict", ".", "values", "(", ")", ")", "+", "1", ")", "]", "for", "word", ",", "index", "in", "word_dict", ".", "items", "(", ")", ":", "if", "not", "word", ":", "continue", "if", "ignore_case", ":", "word", "=", "word", ".", "lower", "(", ")", "if", "word", "in", "pre_trained", ":", "weights", "[", "index", "]", "=", "pre_trained", "[", "word", "]", "else", ":", "weights", "[", "index", "]", "=", "numpy", ".", "random", ".", "random", "(", "(", "embd_dim", ",", ")", ")", ".", "tolist", "(", ")", "return", "numpy", ".", "asarray", "(", "weights", ")" ]

[ "Load", "pre", "-", "trained", "embeddings", "from", "a", "text", "file", "." ]

[ "def", "_dict_from_dotted", "(", "key", ",", "val", ")", ":", "split_key", "=", "key", ".", "split", "(", "\".\"", ")", "split_key", ".", "reverse", "(", ")", "for", "key_part", "in", "split_key", ":", "new_dict", "=", "DotDict", "(", ")", "new_dict", "[", "key_part", "]", "=", "val", "val", "=", "new_dict", "return", "val" ]

[ "takes", "a", "key", "value", "pair", "like", ":", "key", ":", "this", ".", "is", ".", "a", ".", "key", "val", ":", "the", "value" ]

[ "def", "ensure_block_device", "(", "block_device", ")", ":", "_none", "=", "[", "'None'", ",", "'none'", ",", "None", "]", "if", "(", "block_device", "in", "_none", ")", ":", "error_out", "(", "'prepare_storage(): Missing required input: block_device=%s.'", "%", "block_device", ")", "if", "block_device", ".", "startswith", "(", "'/dev/'", ")", ":", "bdev", "=", "block_device", "elif", "block_device", ".", "startswith", "(", "'/'", ")", ":", "_bd", "=", "block_device", ".", "split", "(", "'|'", ")", "if", "len", "(", "_bd", ")", "==", "2", ":", "bdev", ",", "size", "=", "_bd", "else", ":", "bdev", "=", "block_device", "size", "=", "DEFAULT_LOOPBACK_SIZE", "bdev", "=", "ensure_loopback_device", "(", "bdev", ",", "size", ")", "else", ":", "bdev", "=", "'/dev/%s'", "%", "block_device", "if", "not", "is_block_device", "(", "bdev", ")", ":", "error_out", "(", "'Failed to locate valid block device at %s'", "%", "bdev", ")", "return", "bdev" ]

[ "Confirm", "block_device", "create", "as", "loopback", "if", "necessary", "." ]

[ "def", "stop", "(", "self", ")", ":", "LOGGER", ".", "debug", "(", "\"rabbitmq.Driver.stop\"", ")", "for", "requester", "in", "self", ".", "requester_registry", ":", "requester", ".", "stop", "(", ")", "self", ".", "requester_registry", ".", "clear", "(", ")", "for", "service", "in", "self", ".", "services_registry", ":", "if", "service", ".", "is_started", ":", "service", ".", "stop", "(", ")", "self", ".", "services_registry", ".", "clear", "(", ")", "pykka", ".", "ActorRegistry", ".", "stop_all", "(", ")", "return", "self" ]

[ "Stop", "services", "and", "requestors", "and", "then", "connection", ".", ":", "return", ":", "self" ]

[ "async", "def", "_report_version", "(", "self", ")", ":", "# get next two bytes", "major", "=", "await", "self", ".", "read", "(", ")", "version_string", "=", "str", "(", "major", ")", "minor", "=", "await", "self", ".", "read", "(", ")", "version_string", "+=", "'.'", "version_string", "+=", "str", "(", "minor", ")", "self", ".", "query_reply_data", "[", "PrivateConstants", ".", "REPORT_VERSION", "]", "=", "version_string" ]

[ "This", "is", "a", "private", "message", "handler", "method", ".", "This", "method", "reads", "the", "following", "2", "bytes", "after", "the", "report", "version", "command", "(", "0xF9", "-", "non", "sysex", ")", ".", "The", "first", "byte", "is", "the", "major", "number", "and", "the", "second", "byte", "is", "the", "minor", "number", "." ]

[ "async", "def", "get_chat_administrators", "(", "self", ",", "chat_id", ":", "typing", ".", "Union", "[", "base", ".", "Integer", ",", "base", ".", "String", "]", ")", "->", "typing", ".", "List", "[", "types", ".", "ChatMember", "]", ":", "payload", "=", "generate_payload", "(", "*", "*", "locals", "(", ")", ")", "result", "=", "await", "self", ".", "request", "(", "api", ".", "Methods", ".", "GET_CHAT_ADMINISTRATORS", ",", "payload", ")", "return", "[", "types", ".", "ChatMember", "(", "*", "*", "chatmember", ")", "for", "chatmember", "in", "result", "]" ]

[ "Use", "this", "method", "to", "get", "a", "list", "of", "administrators", "in", "a", "chat", "." ]

[ "def", "get_visible_children", "(", "self", ",", "parent", ",", "locator", ",", "params", "=", "None", ",", "timeout", "=", "None", ")", ":", "return", "self", ".", "get_present_children", "(", "parent", ",", "locator", ",", "params", ",", "timeout", ",", "True", ")" ]

[ "Get", "child", "-", "elements", "both", "present", "AND", "visible", "in", "the", "DOM", "." ]

[ "def", "saveDataSet", "(", "settings", ",", "key", ",", "dataSet", ")", ":", "for", "datakey", ",", "value", "in", "dataSet", ".", "items", "(", ")", ":", "datatype", "=", "type", "(", "value", ")", ".", "__name__", "if", "(", "datatype", "in", "_dataValueTypes", ")", ":", "datavalue", "=", "_dataValueTypes", "[", "datatype", "]", "[", "0", "]", "(", "value", ")", "else", ":", "datavalue", "=", "value", "settings", ".", "setValue", "(", "'%s/%s/type'", "%", "(", "key", ",", "datakey", ")", ",", "wrapVariant", "(", "datatype", ")", ")", "settings", ".", "setValue", "(", "'%s/%s/value'", "%", "(", "key", ",", "datakey", ")", ",", "wrapVariant", "(", "datavalue", ")", ")" ]

[ "Records", "the", "dataset", "settings", "to", "the", "inputed", "data", "set", "for", "the", "given", "key", ".", ":", "param", "settings", "|", "<QSettings", ">", "key", "|", "<str", ">", "dataSet", "|", "<projex", ".", "dataset", ".", "DataSet", ">" ]

[ "def", "remove_edge", "(", "self", ",", "u", ",", "v", ",", "key", "=", "None", ")", ":", "try", ":", "d", "=", "self", ".", "adj", "[", "u", "]", "[", "v", "]", "except", "KeyError", ":", "raise", "NetworkXError", "(", "\"The edge {}-{} is not in the graph.\"", ".", "format", "(", "u", ",", "v", ")", ")", "if", "key", "is", "None", ":", "d", ".", "popitem", "(", ")", "else", ":", "try", ":", "del", "d", "[", "key", "]", "except", "KeyError", ":", "raise", "NetworkXError", "(", "\"The edge {}-{} with key {} is not in the graph.\"", ".", "format", "(", "u", ",", "v", ",", "key", ")", ")", "if", "len", "(", "d", ")", "==", "0", ":", "del", "self", ".", "succ", "[", "u", "]", "[", "v", "]" ]

[ "Version", "of", "remove_edge", "that", "s", "much", "like", "normal", "networkx", "but", "only", "deletes", "once", "since", "the", "database", "doesn", "t", "keep", "separate", "adj", "and", "succ", "mappings" ]

[ "def", "record", "(", "self", ",", "ch_node", ")", ":", "rec", "=", "self", ".", "serialize_node", "(", "ch_node", ")", "self", ".", "history", ".", "append", "(", "rec", ")" ]

[ "Incremental", "changes" ]

[ "def", "del_key", "(", "self", ",", "ref", ")", ":", "if", "ref", "not", "in", "self", ".", "keys", ":", "response", "=", "self", ".", "request", "(", "\"client_del_key %s\"", "%", "(", "ref", ")", ")", "self", ".", "keys", ".", "remove", "(", "ref", ")", "if", "\"success\"", "in", "response", ":", "return", "None", "else", ":", "return", "response" ]

[ "Delete", "a", "key", "." ]

[ "def", "listdir", "(", "self", ",", "name", ")", ":", "return", "[", "]", ",", "[", "obj", ".", "filename", "for", "obj", "in", "cloudstorage", ".", "listbucket", "(", "self", ".", "path", "(", "name", ")", ")", "]" ]

[ "TODO", "collect", "directories" ]

[ "def", "nsamples_to_minsec", "(", "x", ",", "pos", ")", ":", "h", ",", "m", ",", "s", "=", "hourminsec", "(", "x", "/", "16.0", ")", "return", "'{:2.0f}′ {:2.1f}″'.for", "m", "at(m+(", "h", "*", "6", "0", ")", ",", " s", ")", "", "", "" ]

[ "Convert", "axes", "labels", "to", "experiment", "duration", "in", "minutes", "/", "seconds" ]

[ "def", "fetch_pdb", "(", "self", ",", "pdb_code", ")", ":", "self", ".", "pdb_path", ",", "self", ".", "pdb_text", "=", "self", ".", "_fetch_pdb", "(", "pdb_code", ")", "self", ".", "_df", "=", "self", ".", "_construct_df", "(", "pdb_lines", "=", "self", ".", "pdb_text", ".", "splitlines", "(", "True", ")", ")", "return", "self" ]

[ "Fetches", "PDB", "file", "contents", "from", "the", "Protein", "Databank", "at", "rcsb", ".", "org", "." ]

[ "def", "add", "(", "self", ",", "cbobject", ",", "metadata", ")", ":", "with", "self", ".", "_lock", ":", "if", "cbobject", "not", "in", "self", ".", "_metadata", ":", "self", ".", "_metadata", "[", "cbobject", "]", "=", "metadata", "return", "self", ".", "_metadata", "[", "cbobject", "]" ]

[ "Add", "the", "specified", "CoreBluetooth", "item", "with", "the", "associated", "metadata", "if", "it", "doesn", "t", "already", "exist", ".", "Returns", "the", "newly", "created", "or", "preexisting", "metadata", "item", "." ]

[ "def", "getv", "(", "self", ",", "r", ")", ":", "v", "=", "self", ".", "get", "(", "r", ")", "if", "not", "is_unknown", "(", "v", ")", ":", "try", ":", "v", "=", "int", "(", "v", ")", "except", "ValueError", ":", "v", "=", "None", "else", ":", "v", "=", "None", "return", "v" ]

[ "Like", "the", "above", "but", "returns", "the", "<int", ">", "value", "." ]

[ "def", "get_double_or_single_prec_mdrun", "(", ")", ":", "try", ":", "gromacs", ".", "mdrun_d", "(", "h", "=", "True", ",", "stdout", "=", "False", ",", "stderr", "=", "False", ")", "logger", ".", "debug", "(", "\"using double precision gromacs.mdrun_d\"", ")", "return", "gromacs", ".", "mdrun_d", "except", "(", "AttributeError", ",", "GromacsError", ",", "OSError", ")", ":", "# fall back to mdrun if no double precision binary", "wmsg", "=", "\"No 'mdrun_d' binary found so trying 'mdrun' instead.\\n\"", "\"(Note that energy minimization runs better with mdrun_d.)\"", "logger", ".", "warn", "(", "wmsg", ")", "warnings", ".", "warn", "(", "wmsg", ",", "category", "=", "AutoCorrectionWarning", ")", "return", "gromacs", ".", "mdrun" ]

[ "Return", "double", "precision", "mdrun", "or", "fall", "back", "to", "single", "precision", "." ]

[ "def", "_setup_db", "(", "cls", ")", ":", "uri", "=", "cls", ".", "_app", ".", "config", ".", "get", "(", "\"DB_URL\"", ")", "if", "uri", ":", "db", ".", "connect__", "(", "uri", ",", "cls", ".", "_app", ")" ]

[ "Setup", "the", "DB", "connection", "if", "DB_URL", "is", "set" ]

[ "def", "dump_registers", "(", "cls", ",", "registers", ",", "arch", "=", "None", ")", ":", "if", "registers", "is", "None", ":", "return", "''", "if", "arch", "is", "None", ":", "if", "'Eax'", "in", "registers", ":", "arch", "=", "win32", ".", "ARCH_I386", "elif", "'Rax'", "in", "registers", ":", "arch", "=", "win32", ".", "ARCH_AMD64", "else", ":", "arch", "=", "'Unknown'", "if", "arch", "not", "in", "cls", ".", "reg_template", ":", "msg", "=", "\"Don't know how to dump the registers for architecture: %s\"", "raise", "NotImplementedError", "(", "msg", "%", "arch", ")", "registers", "=", "registers", ".", "copy", "(", ")", "registers", "[", "'efl_dump'", "]", "=", "cls", ".", "dump_flags", "(", "registers", "[", "'EFlags'", "]", ")", "return", "cls", ".", "reg_template", "[", "arch", "]", "%", "registers" ]

[ "Dump", "the", "x86", "/", "x64", "processor", "register", "values", ".", "The", "output", "mimics", "that", "of", "the", "WinDBG", "debugger", "." ]

[ "def", "add_string_pairs_from_attributed_ui_element", "(", "results", ",", "ui_element", ",", "comment_prefix", ")", ":", "attributed_strings", "=", "ui_element", ".", "getElementsByTagName", "(", "'attributedString'", ")", "if", "attributed_strings", ".", "length", "==", "0", ":", "return", "False", "attributed_element", "=", "attributed_strings", "[", "0", "]", "fragment_index", "=", "1", "for", "fragment", "in", "attributed_element", ".", "getElementsByTagName", "(", "'fragment'", ")", ":", "# The fragment text is either as an attribute <fragment content=\"TEXT\">", "# or a child in the format <string key='content'>TEXT</string>", "try", ":", "label_entry_key", "=", "fragment", ".", "attributes", "[", "'content'", "]", ".", "value", "except", "KeyError", ":", "label_entry_key", "=", "fragment", ".", "getElementsByTagName", "(", "'string'", ")", "[", "0", "]", ".", "firstChild", ".", "nodeValue", "comment", "=", "\"%s Part %d\"", "%", "(", "comment_prefix", ",", "fragment_index", ")", "results", ".", "append", "(", "(", "label_entry_key", ",", "comment", ")", ")", "fragment_index", "+=", "1", "return", "fragment_index", ">", "1" ]

[ "Adds", "string", "pairs", "from", "a", "UI", "element", "with", "attributed", "text" ]

[ "def", "pearson_correlation_coefficient", "(", "predictions", ",", "labels", ",", "weights_fn", "=", "None", ")", ":", "del", "weights_fn", "_", ",", "pearson", "=", "tf", ".", "contrib", ".", "metrics", ".", "streaming_pearson_correlation", "(", "predictions", ",", "labels", ")", "return", "pearson", ",", "tf", ".", "constant", "(", "1.0", ")" ]

[ "Calculate", "pearson", "correlation", "coefficient", "." ]

[ "def", "hash", "(", "self", ")", ":", "hash_list", "=", "[", "]", "for", "key", ",", "value", "in", "sorted", "(", "self", ".", "__dict__", ".", "items", "(", ")", ")", ":", "if", "not", "callable", "(", "value", ")", ":", "if", "isinstance", "(", "value", ",", "np", ".", "ndarray", ")", ":", "hash_list", ".", "append", "(", "value", ".", "tostring", "(", ")", ")", "else", ":", "hash_list", ".", "append", "(", "str", "(", "value", ")", ")", "return", "hashlib", ".", "md5", "(", "repr", "(", "hash_list", ")", ".", "encode", "(", ")", ")", ".", "hexdigest", "(", ")" ]

[ "Return", "an", "hash", "string", "computed", "on", "the", "PSF", "data", "." ]

[ "def", "coreBurkAlpha", "(", "self", ",", "R", ",", "Rs", ",", "rho0", ",", "r_core", ",", "ax_x", ",", "ax_y", ")", ":", "x", "=", "R", "*", "Rs", "**", "-", "1", "p", "=", "Rs", "*", "r_core", "**", "-", "1", "gx", "=", "self", ".", "_G", "(", "x", ",", "p", ")", "a", "=", "2", "*", "rho0", "*", "Rs", "**", "2", "*", "gx", "/", "x", "return", "a", "*", "ax_x", "/", "R", ",", "a", "*", "ax_y", "/", "R" ]

[ "deflection", "angle" ]

[ "def", "recv", "(", "self", ",", "x", "=", "BPF_BUFFER_LENGTH", ")", ":", "if", "self", ".", "buffered_frames", "(", ")", ":", "# Get a frame from the buffer", "return", "self", ".", "get_frame", "(", ")", "# Get data from BPF", "try", ":", "bpf_buffer", "=", "os", ".", "read", "(", "self", ".", "ins", ",", "x", ")", "except", "EnvironmentError", "as", "exc", ":", "if", "exc", ".", "errno", "!=", "errno", ".", "EAGAIN", ":", "warning", "(", "\"BPF recv()\"", ",", "exc_info", "=", "True", ")", "return", "# Extract all frames from the BPF buffer", "self", ".", "extract_frames", "(", "bpf_buffer", ")", "return", "self", ".", "get_frame", "(", ")" ]

[ "Receive", "a", "frame", "from", "the", "network" ]

[ "def", "prepare_namespace", "(", "self", ",", "func", ")", ":", "if", "self", ".", "is_imethod", ":", "to_run", "=", "getattr", "(", "self", ".", "obj", ",", "self", ".", "imethod_name", ")", "else", ":", "to_run", "=", "func", "for", "varname", ",", "modulename", "in", "self", ".", "global_modules", ".", "items", "(", ")", ":", "to_run", ".", "__globals__", "[", "varname", "]", "=", "__import__", "(", "modulename", ")", "if", "self", ".", "global_closure", ":", "to_run", ".", "__globals__", ".", "update", "(", "self", ".", "global_closure", ")", "if", "self", ".", "global_functions", ":", "to_run", ".", "__globals__", ".", "update", "(", "self", ".", "global_functions", ")", "return", "to_run" ]

[ "Prepares", "the", "function", "to", "be", "run", "after", "deserializing", "it", ".", "Re", "-", "associates", "any", "previously", "bound", "variables", "and", "modules", "from", "the", "closure" ]

[ "def", "safe_modulo", "(", "s", ",", "meta", ",", "checked", "=", "''", ",", "print_warning", "=", "True", ",", "stacklevel", "=", "2", ")", ":", "try", ":", "return", "s", "%", "meta", "except", "(", "ValueError", ",", "TypeError", ",", "KeyError", ")", ":", "# replace the missing fields by %%", "keys", "=", "substitution_pattern", ".", "finditer", "(", "s", ")", "for", "m", "in", "keys", ":", "key", "=", "m", ".", "group", "(", "'key'", ")", "if", "not", "isinstance", "(", "meta", ",", "dict", ")", "or", "key", "not", "in", "meta", ":", "if", "print_warning", ":", "warn", "(", "\"%r is not a valid key!\"", "%", "key", ",", "SyntaxWarning", ",", "stacklevel", ")", "full", "=", "m", ".", "group", "(", ")", "s", "=", "s", ".", "replace", "(", "full", ",", "'%'", "+", "full", ")", "if", "'KEY'", "not", "in", "checked", ":", "return", "safe_modulo", "(", "s", ",", "meta", ",", "checked", "=", "checked", "+", "'KEY'", ",", "print_warning", "=", "print_warning", ",", "stacklevel", "=", "stacklevel", ")", "if", "not", "isinstance", "(", "meta", ",", "dict", ")", "or", "'VALUE'", "in", "checked", ":", "raise", "s", "=", "re", ".", "sub", "(", "r\"\"\"(?<!%)(%%)*%(?!%) # uneven number of %\n \\s*(\\w|$) # format strings\"\"\"", ",", "'%\\g<0>'", ",", "s", ",", "flags", "=", "re", ".", "VERBOSE", ")", "return", "safe_modulo", "(", "s", ",", "meta", ",", "checked", "=", "checked", "+", "'VALUE'", ",", "print_warning", "=", "print_warning", ",", "stacklevel", "=", "stacklevel", ")" ]

[ "Safe", "version", "of", "the", "modulo", "operation", "(", "%", ")", "of", "strings" ]

[ "def", "from_short_lines_text", "(", "self", ",", "text", ":", "str", ")", ":", "Metre", ".", "from_short_lines_text", "(", "self", ",", "text", ")", "self", ".", "short_lines", "=", "[", "ShortLine", "(", "line", ")", "for", "line", "in", "text", ".", "split", "(", "\"\\n\"", ")", "if", "line", "]", "self", ".", "long_lines", "=", "None" ]

[ "Example", "from", "Völsupá", "28", ">>>", "stanza", "=", "Ein", "sat", "hon", "úti", "\\\\", "nþá", "er", "inn", "aldni", "kom", "\\\\", "nyggjungr", "ása", "\\\\", "nok", "í", "augu", "leit", ".", "\\\\", "nHvers", "fregnið", "mik?", "\\\\", "nHví", "freistið", "mín?", "\\\\", "nAllt", "veit", "ek", "Óðinn", "\\\\", "nhvar", "þú", "auga", "falt", "\\\\", "ní", "inum", "mæra", "\\\\", "nMímisbrunni", ".", "\\\\", "nDrekkr", "mjöð", "Mímir", "\\\\", "nmorgun", "hverjan", "\\\\", "naf", "veði", "Valföðrs", ".", "\\\\", "nVituð", "ér", "enn", "-", "eða", "hvat?", ">>>", "us", "=", "UnspecifiedStanza", "()", ">>>", "us", ".", "from_short_lines_text", "(", "stanza", ")", ">>>", "[", "sl", ".", "text", "for", "sl", "in", "us", ".", "short_lines", "]", "[", "Ein", "sat", "hon", "úti", "þá", "er", "inn", "aldni", "kom", "yggjungr", "ása", "ok", "í", "augu", "leit", ".", "Hvers", "fregnið", "mik?", "Hví", "freistið", "mín?", "Allt", "veit", "ek", "Óðinn", "hvar", "þú", "auga", "falt", "í", "inum", "mæra", "Mímisbrunni", ".", "Drekkr", "mjöð", "Mímir", "morgun", "hverjan", "af", "veði", "Valföðrs", ".", "Vituð", "ér", "enn", "-", "eða", "hvat?", "]", ">>>", "us", ".", "long_lines" ]

[ "def", "svmachine", "(", "self", ",", "data", ":", "[", "'SASdata'", ",", "str", "]", "=", "None", ",", "autotune", ":", "str", "=", "None", ",", "code", ":", "str", "=", "None", ",", "id", ":", "str", "=", "None", ",", "input", ":", "[", "str", ",", "list", ",", "dict", "]", "=", "None", ",", "kernel", ":", "str", "=", "None", ",", "output", ":", "[", "str", ",", "bool", ",", "'SASdata'", "]", "=", "None", ",", "partition", ":", "str", "=", "None", ",", "savestate", ":", "str", "=", "None", ",", "solver", ":", "str", "=", "None", ",", "target", ":", "[", "str", ",", "list", ",", "dict", "]", "=", "None", ",", "procopts", ":", "str", "=", "None", ",", "stmtpassthrough", ":", "str", "=", "None", ",", "*", "*", "kwargs", ":", "dict", ")", "->", "'SASresults'", ":" ]

[ "Python", "method", "to", "call", "the", "SVMACHINE", "procedure" ]

[ "def", "image_single_point_source", "(", "self", ",", "image_model_class", ",", "kwargs_lens", ",", "kwargs_source", ",", "kwargs_lens_light", ",", "kwargs_ps", ")", ":", "# reconstructed model with given psf", "model", ",", "error_map", ",", "cov_param", ",", "param", "=", "image_model_class", ".", "image_linear_solve", "(", "kwargs_lens", ",", "kwargs_source", ",", "kwargs_lens_light", ",", "kwargs_ps", ")", "#model = image_model_class.image(kwargs_lens, kwargs_source, kwargs_lens_light, kwargs_ps)", "data", "=", "image_model_class", ".", "Data", ".", "data", "mask", "=", "image_model_class", ".", "ImageNumerics", ".", "mask", "point_source_list", "=", "image_model_class", ".", "point_sources_list", "(", "kwargs_ps", ",", "kwargs_lens", ")", "n", "=", "len", "(", "point_source_list", ")", "model_single_source_list", "=", "[", "]", "for", "i", "in", "range", "(", "n", ")", ":", "model_single_source", "=", "(", "data", "-", "model", "+", "point_source_list", "[", "i", "]", ")", "*", "mask", "model_single_source_list", ".", "append", "(", "model_single_source", ")", "return", "model_single_source_list" ]

[ "return", "model", "without", "including", "the", "point", "source", "contributions", "as", "a", "list", "(", "for", "each", "point", "source", "individually", ")", ":", "param", "image_model_class", ":", "ImageModel", "class", "instance", ":", "param", "kwargs_lens", ":", "lens", "model", "kwargs", "list", ":", "param", "kwargs_source", ":", "source", "model", "kwargs", "list", ":", "param", "kwargs_lens_light", ":", "lens", "light", "model", "kwargs", "list", ":", "param", "kwargs_ps", ":", "point", "source", "model", "kwargs", "list", ":", "return", ":", "list", "of", "images", "with", "point", "source", "isolated" ]

[ "def", "load_configuration_file", "(", "self", ",", "configuration_file", ")", ":", "configuration_file", "=", "parse_path", "(", "configuration_file", ")", "logger", ".", "debug", "(", "\"Loading configuration file: %s\"", ",", "configuration_file", ")", "parser", "=", "configparser", ".", "RawConfigParser", "(", ")", "files_loaded", "=", "parser", ".", "read", "(", "configuration_file", ")", "if", "len", "(", "files_loaded", ")", "!=", "1", ":", "msg", "=", "\"Failed to load configuration file! (%s)\"", "raise", "Exception", "(", "msg", "%", "configuration_file", ")", "elif", "not", "parser", ".", "has_section", "(", "'pip-accel'", ")", ":", "msg", "=", "\"Missing 'pip-accel' section in configuration file! (%s)\"", "raise", "Exception", "(", "msg", "%", "configuration_file", ")", "else", ":", "self", ".", "configuration", ".", "update", "(", "parser", ".", "items", "(", "'pip-accel'", ")", ")" ]

[ "Load", "configuration", "defaults", "from", "a", "configuration", "file", "." ]

[ "def", "findLibrary", "(", "name", ")", ":", "assert", "is_unix", ",", "\"Current implementation for Unix only (Linux, Solaris, AIX)\"", "lib", "=", "None", "# Look in the LD_LIBRARY_PATH", "lp", "=", "compat", ".", "getenv", "(", "'LD_LIBRARY_PATH'", ",", "''", ")", "for", "path", "in", "lp", ".", "split", "(", "os", ".", "pathsep", ")", ":", "libs", "=", "glob", "(", "os", ".", "path", ".", "join", "(", "path", ",", "name", "+", "'*'", ")", ")", "if", "libs", ":", "lib", "=", "libs", "[", "0", "]", "break", "# Look in /etc/ld.so.cache", "if", "lib", "is", "None", ":", "expr", "=", "r'/[^\\(\\)\\s]*%s\\.[^\\(\\)\\s]*'", "%", "re", ".", "escape", "(", "name", ")", "m", "=", "re", ".", "search", "(", "expr", ",", "compat", ".", "exec_command", "(", "'/sbin/ldconfig'", ",", "'-p'", ")", ")", "if", "m", ":", "lib", "=", "m", ".", "group", "(", "0", ")", "# Look in the known safe paths", "if", "lib", "is", "None", ":", "paths", "=", "[", "'/lib'", ",", "'/usr/lib'", "]", "if", "is_aix", ":", "paths", ".", "append", "(", "'/opt/freeware/lib'", ")", "for", "path", "in", "paths", ":", "libs", "=", "glob", "(", "os", ".", "path", ".", "join", "(", "path", ",", "name", "+", "'*'", ")", ")", "if", "libs", ":", "lib", "=", "libs", "[", "0", "]", "break", "# give up :(", "if", "lib", "is", "None", ":", "return", "None", "# Resolve the file name into the soname", "dir", ",", "file", "=", "os", ".", "path", ".", "split", "(", "lib", ")", "return", "os", ".", "path", ".", "join", "(", "dir", ",", "getSoname", "(", "lib", ")", ")" ]

[ "Look", "for", "a", "library", "in", "the", "system", "." ]

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

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

[ "def", "qsat", "(", "self", ",", "temp", ",", "pres", ",", "parameter", ")", ":", "gamw", "=", "(", "parameter", ".", "cl", "-", "parameter", ".", "cpv", ")", "/", "parameter", ".", "rv", "betaw", "=", "(", "parameter", ".", "lvtt", "/", "parameter", ".", "rv", ")", "+", "(", "gamw", "*", "parameter", ".", "tt", ")", "alpw", "=", "math", ".", "log", "(", "parameter", ".", "estt", ")", "+", "(", "betaw", "/", "parameter", ".", "tt", ")", "+", "(", "gamw", "*", "math", ".", "log", "(", "parameter", ".", "tt", ")", ")", "work2", "=", "parameter", ".", "r", "/", "parameter", ".", "rv", "foes_lst", "=", "[", "0", "for", "i", "in", "range", "(", "len", "(", "temp", ")", ")", "]", "work1_lst", "=", "[", "0", "for", "i", "in", "range", "(", "len", "(", "temp", ")", ")", "]", "qsat_lst", "=", "[", "0", "for", "i", "in", "range", "(", "len", "(", "temp", ")", ")", "]", "for", "i", "in", "range", "(", "len", "(", "temp", ")", ")", ":", "# saturation vapor pressure", "foes_lst", "[", "i", "]", "=", "math", ".", "exp", "(", "alpw", "-", "betaw", "/", "temp", "[", "i", "]", "-", "gamw", "*", "math", ".", "log", "(", "temp", "[", "i", "]", ")", ")", "work1_lst", "[", "i", "]", "=", "foes_lst", "[", "i", "]", "/", "pres", "[", "i", "]", "# saturation humidity", "qsat_lst", "[", "i", "]", "=", "work2", "*", "work1_lst", "[", "i", "]", "/", "(", "1.", "+", "(", "work2", "-", "1.", ")", "*", "work1_lst", "[", "i", "]", ")", "return", "qsat_lst" ]

[ "Calculate", "(", "qsat_lst", ")", "vector", "of", "saturation", "humidity", "from", ":", "temp", "=", "vector", "of", "element", "layer", "temperatures", "pres", "=", "pressure", "(", "at", "current", "timestep", ")", "." ]

[ "def", "get_file_hash", "(", "fpath", ",", "blocksize", "=", "65536", ",", "hasher", "=", "None", ",", "stride", "=", "1", ",", "hexdigest", "=", "False", ")", ":", "if", "hasher", "is", "None", ":", "hasher", "=", "hashlib", ".", "sha1", "(", ")", "with", "open", "(", "fpath", ",", "'rb'", ")", "as", "file_", ":", "buf", "=", "file_", ".", "read", "(", "blocksize", ")", "while", "len", "(", "buf", ")", ">", "0", ":", "hasher", ".", "update", "(", "buf", ")", "if", "stride", ">", "1", ":", "file_", ".", "seek", "(", "blocksize", "*", "(", "stride", "-", "1", ")", ",", "1", ")", "# skip blocks", "buf", "=", "file_", ".", "read", "(", "blocksize", ")", "if", "hexdigest", ":", "return", "hasher", ".", "hexdigest", "(", ")", "else", ":", "return", "hasher", ".", "digest", "(", ")" ]

[ "r", "For", "better", "hashes", "use", "hasher", "=", "hashlib", ".", "sha256", "and", "keep", "stride", "=", "1" ]

[ "def", "line_spacing", "(", "self", ")", ":", "pPr", "=", "self", ".", "_element", ".", "pPr", "if", "pPr", "is", "None", ":", "return", "None", "return", "self", ".", "_line_spacing", "(", "pPr", ".", "spacing_line", ",", "pPr", ".", "spacing_lineRule", ")" ]

[ "|float|", "or", "|Length|", "value", "specifying", "the", "space", "between", "baselines", "in", "successive", "lines", "of", "the", "paragraph", ".", "A", "value", "of", "|None|", "indicates", "line", "spacing", "is", "inherited", "from", "the", "style", "hierarchy", ".", "A", "float", "value", "e", ".", "g", ".", "2", ".", "0", "or", "1", ".", "75", "indicates", "spacing", "is", "applied", "in", "multiples", "of", "line", "heights", ".", "A", "|Length|", "value", "such", "as", "Pt", "(", "12", ")", "indicates", "spacing", "is", "a", "fixed", "height", ".", "The", "|Pt|", "value", "class", "is", "a", "convenient", "way", "to", "apply", "line", "spacing", "in", "units", "of", "points", ".", "Assigning", "|None|", "resets", "line", "spacing", "to", "inherit", "from", "the", "style", "hierarchy", "." ]

[ "def", "read_packages", "(", "reqs_file", ")", ":", "for", "line", "in", "stream_file_lines", "(", "reqs_file", ")", ":", "line", "=", "line", ".", "strip", "(", ")", "if", "not", "line", ".", "startswith", "(", "(", "'#'", ",", "'--hash'", ")", ")", ":", "match", "=", "DEP_PATTERN", ".", "match", "(", "line", ")", "if", "match", ":", "package", ",", "version", ",", "marker", "=", "match", ".", "groups", "(", ")", "yield", "Package", "(", "package", ".", "lower", "(", ")", ",", "version", ",", "marker", ")" ]

[ "Generator", "yielding", "one", "Package", "instance", "for", "every", "corresponing", "line", "in", "a", "requirements", "file" ]

[ "def", "certificate_rabbitmq", "(", "self", ")", ":", "if", "not", "self", ".", "__certificate_rabbitmq", ":", "self", ".", "__certificate_rabbitmq", "=", "CertificateRabbitMQ", "(", "self", ".", "__connection", ")", "return", "self", ".", "__certificate_rabbitmq" ]

[ "Gets", "the", "Certificate", "RabbitMQ", "API", "client", "." ]

[ "def", "add_substitution", "(", "self", ",", "substitution", ")", ":", "if", "substitution", ".", "personalization", ":", "try", ":", "personalization", "=", "self", ".", "_personalizations", "[", "substitution", ".", "personalization", "]", "has_internal_personalization", "=", "True", "except", "IndexError", ":", "personalization", "=", "Personalization", "(", ")", "has_internal_personalization", "=", "False", "personalization", ".", "add_substitution", "(", "substitution", ")", "if", "not", "has_internal_personalization", ":", "self", ".", "add_personalization", "(", "personalization", ",", "index", "=", "substitution", ".", "personalization", ")", "else", ":", "if", "isinstance", "(", "substitution", ",", "list", ")", ":", "for", "s", "in", "substitution", ":", "for", "p", "in", "self", ".", "personalizations", ":", "p", ".", "add_substitution", "(", "s", ")", "else", ":", "for", "p", "in", "self", ".", "personalizations", ":", "p", ".", "add_substitution", "(", "substitution", ")" ]

[ "Add", "a", "substitution", "to", "the", "email" ]

[ "def", "sample_truncated_gaussian", "(", "mu", "=", "0", ",", "sigma", "=", "1", ",", "lb", "=", "-", "np", ".", "Inf", ",", "ub", "=", "np", ".", "Inf", ")", ":", "# Broadcast arrays to be of the same shape", "mu", ",", "sigma", ",", "lb", ",", "ub", "=", "np", ".", "broadcast_arrays", "(", "mu", ",", "sigma", ",", "lb", ",", "ub", ")", "shp", "=", "mu", ".", "shape", "if", "np", ".", "allclose", "(", "sigma", ",", "0.0", ")", ":", "return", "mu", "cdflb", "=", "normal_cdf", "(", "lb", ",", "mu", ",", "sigma", ")", "cdfub", "=", "normal_cdf", "(", "ub", ",", "mu", ",", "sigma", ")", "# Sample uniformly from the CDF", "cdfsamples", "=", "cdflb", "+", "np", ".", "random", ".", "rand", "(", "*", "shp", ")", "*", "(", "cdfub", "-", "cdflb", ")", "# Clip the CDF samples so that we can invert them", "cdfsamples", "=", "np", ".", "clip", "(", "cdfsamples", ",", "1e-15", ",", "1", "-", "1e-15", ")", "zs", "=", "-", "np", ".", "sqrt", "(", "2", ")", "*", "special", ".", "erfcinv", "(", "2", "*", "cdfsamples", ")", "# Transform the standard normal samples", "xs", "=", "sigma", "*", "zs", "+", "mu", "xs", "=", "np", ".", "clip", "(", "xs", ",", "lb", ",", "ub", ")", "return", "xs" ]

[ "Sample", "a", "truncated", "normal", "with", "the", "specified", "params", ".", "This", "is", "not", "the", "most", "stable", "way", "but", "it", "works", "as", "long", "as", "the", "truncation", "region", "is", "not", "too", "far", "from", "the", "mean", "." ]

[ "def", "mean", "(", "self", ")", "->", "Optional", "[", "float", "]", ":", "if", "self", ".", "_stats", ":", "# TODO: should be true always?", "if", "self", ".", "total", ">", "0", ":", "return", "self", ".", "_stats", "[", "\"sum\"", "]", "/", "self", ".", "total", "else", ":", "return", "np", ".", "nan", "else", ":", "return", "None" ]

[ "Statistical", "mean", "of", "all", "values", "entered", "into", "histogram", "." ]

[ "def", "make_serviceitem_servicedllmd5sum", "(", "servicedll_md5", ",", "condition", "=", "'is'", ",", "negate", "=", "False", ")", ":", "document", "=", "'ServiceItem'", "search", "=", "'ServiceItem/serviceDLLmd5sum'", "content_type", "=", "'md5'", "content", "=", "servicedll_md5", "ii_node", "=", "ioc_api", ".", "make_indicatoritem_node", "(", "condition", ",", "document", ",", "search", ",", "content_type", ",", "content", ",", "negate", "=", "negate", ")", "return", "ii_node" ]

[ "Create", "a", "node", "for", "ServiceItem", "/", "serviceDLLmd5sum", ":", "return", ":", "A", "IndicatorItem", "represented", "as", "an", "Element", "node" ]

[ "def", "find_python_files", "(", "dirname", ")", ":", "for", "i", ",", "(", "dirpath", ",", "dirnames", ",", "filenames", ")", "in", "enumerate", "(", "os", ".", "walk", "(", "dirname", ")", ")", ":", "if", "i", ">", "0", "and", "'__init__.py'", "not", "in", "filenames", ":", "# If a directory doesn't have __init__.py, then it isn't", "# importable and neither are its files", "del", "dirnames", "[", ":", "]", "continue", "for", "filename", "in", "filenames", ":", "# We're only interested in files that look like reasonable Python", "# files: Must end with .py or .pyw, and must not have certain funny", "# characters that probably mean they are editor junk.", "if", "re", ".", "match", "(", "r\"^[^.#~!$@%^&*()+=,]+\\.pyw?$\"", ",", "filename", ")", ":", "yield", "os", ".", "path", ".", "join", "(", "dirpath", ",", "filename", ")" ]

[ "Yield", "all", "of", "the", "importable", "Python", "files", "in", "dirname", "recursively", "." ]

[ "def", "get_broks", "(", "self", ",", "broker_name", ")", ":", "res", "=", "self", ".", "con", ".", "get", "(", "'_broks'", ",", "{", "'broker_name'", ":", "broker_name", "}", ",", "wait", "=", "False", ")", "logger", ".", "debug", "(", "\"Got broks from %s: %s\"", ",", "self", ".", "name", ",", "res", ")", "return", "unserialize", "(", "res", ",", "True", ")" ]

[ "Send", "a", "HTTP", "request", "to", "the", "satellite", "(", "GET", "/", "_broks", ")", "Get", "broks", "from", "the", "satellite", ".", "Un", "-", "serialize", "data", "received", "." ]

[ "def", "render", "(", "cheetah_data", ",", "saltenv", "=", "'base'", ",", "sls", "=", "''", ",", "method", "=", "'xml'", ",", "*", "*", "kws", ")", ":", "if", "not", "HAS_LIBS", ":", "return", "{", "}", "if", "not", "isinstance", "(", "cheetah_data", ",", "six", ".", "string_types", ")", ":", "cheetah_data", "=", "cheetah_data", ".", "read", "(", ")", "if", "cheetah_data", ".", "startswith", "(", "'#!'", ")", ":", "cheetah_data", "=", "cheetah_data", "[", "(", "cheetah_data", ".", "find", "(", "'\\n'", ")", "+", "1", ")", ":", "]", "if", "not", "cheetah_data", ".", "strip", "(", ")", ":", "return", "{", "}", "return", "six", ".", "text_type", "(", "Template", "(", "cheetah_data", ",", "searchList", "=", "[", "kws", "]", ")", ")" ]

[ "Render", "a", "Cheetah", "template", "." ]

[ "def", "import_string", "(", "dotted_path", ":", "str", ")", "->", "Any", ":", "try", ":", "module_path", ",", "class_name", "=", "dotted_path", ".", "strip", "(", "' '", ")", ".", "rsplit", "(", "'.'", ",", "1", ")", "except", "ValueError", "as", "e", ":", "raise", "ImportError", "(", "f'\"{dotted_path}\" doesn\\'t look like a module path'", ")", "from", "e", "module", "=", "import_module", "(", "module_path", ")", "try", ":", "return", "getattr", "(", "module", ",", "class_name", ")", "except", "AttributeError", "as", "e", ":", "raise", "ImportError", "(", "f'Module \"{module_path}\" does not define a \"{class_name}\" attribute'", ")", "from", "e" ]

[ "Stolen", "approximately", "from", "django", ".", "Import", "a", "dotted", "module", "path", "and", "return", "the", "attribute", "/", "class", "designated", "by", "the", "last", "name", "in", "the", "path", ".", "Raise", "ImportError", "if", "the", "import", "fails", "." ]

[ "def", "search", "(", "*", "*", "kw", ")", ":", "portal", "=", "get_portal", "(", ")", "catalog", "=", "ICatalog", "(", "portal", ")", "catalog_query", "=", "ICatalogQuery", "(", "catalog", ")", "query", "=", "catalog_query", ".", "make_query", "(", "*", "*", "kw", ")", "return", "catalog", "(", "query", ")" ]

[ "Search", "the", "catalog", "adapter" ]

[ "def", "get_service_agreement_hash", "(", "self", ",", "agreement_id", ",", "asset_id", ",", "consumer_address", ",", "publisher_address", ",", "keeper", ")", ":", "agreement_hash", "=", "ServiceAgreement", ".", "generate_service_agreement_hash", "(", "self", ".", "template_id", ",", "self", ".", "generate_agreement_condition_ids", "(", "agreement_id", ",", "asset_id", ",", "consumer_address", ",", "publisher_address", ",", "keeper", ")", ",", "self", ".", "conditions_timelocks", ",", "self", ".", "conditions_timeouts", ",", "agreement_id", ")", "return", "agreement_hash" ]

[ "Return", "the", "hash", "of", "the", "service", "agreement", "values", "to", "be", "signed", "by", "a", "consumer", "." ]

[ "def", "pipe", "(", "self", ",", "other_task", ")", ":", "other_task", ".", "_source", "=", "self", "self", ".", "_listeners", ".", "append", "(", "PipeListener", "(", "other_task", ")", ")", "return", "other_task" ]

[ "Add", "a", "pipe", "listener", "to", "the", "execution", "of", "this", "task", ".", "The", "output", "of", "this", "task", "is", "required", "to", "be", "an", "iterable", ".", "Each", "item", "in", "the", "iterable", "will", "be", "queued", "as", "the", "sole", "argument", "to", "an", "execution", "of", "the", "listener", "task", "." ]

[ "def", "_get_distance_scaling_term", "(", "self", ",", "C", ",", "rjb", ",", "mag", ")", ":", "# Depth adjusted distance, equation 11 (Page 63)", "rval", "=", "np", ".", "sqrt", "(", "rjb", "**", "2.0", "+", "C", "[", "\"c11\"", "]", "**", "2.0", ")", "f_0", ",", "f_1", ",", "f_2", "=", "self", ".", "_get_distance_segment_coefficients", "(", "rval", ")", "return", "(", "(", "C", "[", "\"c4\"", "]", "+", "C", "[", "\"c5\"", "]", "*", "mag", ")", "*", "f_0", "+", "(", "C", "[", "\"c6\"", "]", "+", "C", "[", "\"c7\"", "]", "*", "mag", ")", "*", "f_1", "+", "(", "C", "[", "\"c8\"", "]", "+", "C", "[", "\"c9\"", "]", "*", "mag", ")", "*", "f_2", "+", "(", "C", "[", "\"c10\"", "]", "*", "rval", ")", ")" ]

[ "Returns", "the", "distance", "scaling", "component", "of", "the", "model", "Equation", "10", "Page", "63" ]

[ "def", "prepare_encoder", "(", "inputs", ",", "hparams", ",", "attention_type", "=", "\"local_1d\"", ")", ":", "x", "=", "prepare_image", "(", "inputs", ",", "hparams", ",", "name", "=", "\"enc_channels\"", ")", "# Add position signals.", "x", "=", "add_pos_signals", "(", "x", ",", "hparams", ",", "\"enc_pos\"", ")", "x_shape", "=", "common_layers", ".", "shape_list", "(", "x", ")", "if", "attention_type", "==", "\"local_1d\"", ":", "x", "=", "tf", ".", "reshape", "(", "x", ",", "[", "x_shape", "[", "0", "]", ",", "x_shape", "[", "1", "]", "*", "x_shape", "[", "2", "]", ",", "hparams", ".", "hidden_size", "]", ")", "x", ".", "set_shape", "(", "[", "None", ",", "None", ",", "hparams", ".", "hidden_size", "]", ")", "elif", "attention_type", "==", "\"local_2d\"", ":", "x", ".", "set_shape", "(", "[", "None", ",", "None", ",", "None", ",", "hparams", ".", "hidden_size", "]", ")", "return", "x" ]

[ "Prepare", "encoder", "for", "images", "." ]

[ "def", "is_valid_host", "(", "value", ")", ":", "host_validators", "=", "validators", ".", "ipv4", ",", "validators", ".", "ipv6", ",", "validators", ".", "domain", "return", "any", "(", "f", "(", "value", ")", "for", "f", "in", "host_validators", ")" ]

[ "Check", "if", "given", "value", "is", "a", "valid", "host", "string", "." ]

[ "def", "is_valid_identifier", "(", "identifier", ")", ":", "if", "not", "isinstance", "(", "identifier", ",", "basestring", ")", ":", "return", "False", "if", "len", "(", "identifier", ")", ">", "100", "or", "len", "(", "identifier", ")", "<", "1", ":", "return", "False", "condensed_form", "=", "set", "(", "list", "(", "identifier", ".", "lower", "(", ")", ")", ")", "return", "condensed_form", ".", "issubset", "(", "VALID_IDENTIFIER_SET", ")" ]

[ "Checks", "if", "the", "given", "identifier", "is", "valid", "or", "not", ".", "A", "valid", "identifier", "may", "consists", "of", "the", "following", "characters", "with", "a", "maximum", "length", "of", "100", "characters", "minimum", "of", "1", "character", "." ]

[ "def", "update_queue", "(", "self", ")", ":", "self", ".", "logger", ".", "debug", "(", "\"Updating queue display\"", ")", "queue_display", "=", "[", "]", "for", "i", "in", "range", "(", "self", ".", "queue_display", ")", ":", "try", ":", "if", "len", "(", "self", ".", "queue", "[", "i", "]", "[", "1", "]", ")", ">", "40", ":", "songname", "=", "self", ".", "queue", "[", "i", "]", "[", "1", "]", "[", ":", "37", "]", "+", "\"...\"", "else", ":", "songname", "=", "self", ".", "queue", "[", "i", "]", "[", "1", "]", "except", "IndexError", ":", "songname", "=", "\"---\"", "queue_display", ".", "append", "(", "\"{}. {}\\n\"", ".", "format", "(", "str", "(", "i", "+", "1", ")", ",", "songname", ")", ")", "self", ".", "queuelog", ".", "debug", "(", "''", ".", "join", "(", "queue_display", ")", ")", "self", ".", "queuelenlog", ".", "debug", "(", "str", "(", "len", "(", "self", ".", "queue", ")", ")", ")" ]

[ "Updates", "the", "queue", "in", "the", "music", "player" ]

[ "def", "_unnormalized_option_registrations_iter", "(", "self", ")", ":", "# First yield any recursive options we inherit from our parent.", "if", "self", ".", "_parent_parser", ":", "for", "args", ",", "kwargs", "in", "self", ".", "_parent_parser", ".", "_recursive_option_registration_args", "(", ")", ":", "yield", "args", ",", "kwargs", "# Then yield our directly-registered options.", "for", "args", ",", "kwargs", "in", "self", ".", "_option_registrations", ":", "if", "'recursive'", "in", "kwargs", "and", "self", ".", "_scope_info", ".", "category", "==", "ScopeInfo", ".", "SUBSYSTEM", ":", "raise", "RecursiveSubsystemOption", "(", "self", ".", "scope", ",", "args", "[", "0", "]", ")", "yield", "args", ",", "kwargs" ]

[ "Returns", "an", "iterator", "over", "the", "raw", "registration", "arguments", "of", "each", "option", "in", "this", "parser", "." ]

[ "def", "create", "(", "self", ",", "name", ",", "site_element", ")", ":", "site_element", "=", "element_resolver", "(", "site_element", ")", "json", "=", "{", "'name'", ":", "name", ",", "'site_element'", ":", "site_element", "}", "return", "ElementCreator", "(", "self", ".", "__class__", ",", "href", "=", "self", ".", "href", ",", "json", "=", "json", ")" ]

[ "Create", "a", "VPN", "site", "for", "an", "internal", "or", "external", "gateway" ]

[ "def", "ensure", "(", "self", ",", "name", ",", "preparefunc", ",", "restart", "=", "False", ")", ":", "from", "subprocess", "import", "Popen", ",", "STDOUT", "info", "=", "self", ".", "getinfo", "(", "name", ")", "if", "not", "restart", "and", "not", "info", ".", "isrunning", "(", ")", ":", "restart", "=", "True", "if", "restart", ":", "if", "info", ".", "pid", "is", "not", "None", ":", "info", ".", "terminate", "(", ")", "controldir", "=", "info", ".", "controldir", ".", "ensure", "(", "dir", "=", "1", ")", "#controldir.remove()", "preparefunc", "=", "CompatStarter", ".", "wrap", "(", "preparefunc", ")", "starter", "=", "preparefunc", "(", "controldir", ",", "self", ")", "args", "=", "[", "str", "(", "x", ")", "for", "x", "in", "starter", ".", "args", "]", "self", ".", "log", ".", "debug", "(", "\"%s$ %s\"", ",", "controldir", ",", "\" \"", ".", "join", "(", "args", ")", ")", "stdout", "=", "open", "(", "str", "(", "info", ".", "logpath", ")", ",", "\"wb\"", ",", "0", ")", "kwargs", "=", "{", "'env'", ":", "starter", ".", "env", "}", "if", "sys", ".", "platform", "==", "\"win32\"", ":", "kwargs", "[", "\"startupinfo\"", "]", "=", "sinfo", "=", "std", ".", "subprocess", ".", "STARTUPINFO", "(", ")", "if", "sys", ".", "version_info", ">=", "(", "2", ",", "7", ")", ":", "sinfo", ".", "dwFlags", "|=", "std", ".", "subprocess", ".", "STARTF_USESHOWWINDOW", "sinfo", ".", "wShowWindow", "|=", "std", ".", "subprocess", ".", "SW_HIDE", "else", ":", "kwargs", "[", "\"close_fds\"", "]", "=", "True", "kwargs", "[", "\"preexec_fn\"", "]", "=", "os", ".", "setpgrp", "# no CONTROL-C", "popen", "=", "Popen", "(", "args", ",", "cwd", "=", "str", "(", "controldir", ")", ",", "stdout", "=", "stdout", ",", "stderr", "=", "STDOUT", ",", "*", "*", "kwargs", ")", "info", ".", "pid", "=", "pid", "=", "popen", ".", "pid", "info", ".", "pidpath", ".", "write", "(", "str", "(", "pid", ")", ")", "self", ".", "log", ".", "debug", "(", "\"process %r started pid=%s\"", ",", "name", ",", "pid", ")", "stdout", ".", "close", "(", ")", "f", "=", "info", ".", "logpath", ".", "open", "(", ")", "if", "not", "restart", ":", "f", ".", "seek", "(", "0", ",", "2", ")", "else", ":", "if", "not", "starter", ".", "wait", "(", "f", ")", ":", "raise", "RuntimeError", "(", "\"Could not start process %s\"", "%", "name", ")", "self", ".", "log", ".", "debug", "(", "\"%s process startup detected\"", ",", "name", ")", "logfiles", "=", "self", ".", "config", ".", "__dict__", ".", "setdefault", "(", "\"_extlogfiles\"", ",", "{", "}", ")", "logfiles", "[", "name", "]", "=", "f", "self", ".", "getinfo", "(", "name", ")", "return", "info", ".", "pid", ",", "info", ".", "logpath" ]

[ "returns", "(", "PID", "logfile", ")", "from", "a", "newly", "started", "or", "already", "running", "process", "." ]

[ "def", "imagetransformer_sep_channels_16l_16h_imgnet_lrg_loc_128", "(", ")", ":", "hparams", "=", "imagetransformer_sep_channels_12l_16h_imagenet_large", "(", ")", "hparams", ".", "num_hidden_layers", "=", "16", "hparams", ".", "local_attention", "=", "True", "hparams", ".", "batch_size", "=", "1", "hparams", ".", "block_length", "=", "128", "return", "hparams" ]

[ "separate", "rgb", "embeddings", "." ]

[ "def", "load_cufflinks_fpkm_dict", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "{", "row", ".", "id", ":", "row", ".", "fpkm", "for", "(", "_", ",", "row", ")", "in", "load_cufflinks_dataframe", "(", "*", "args", ",", "*", "*", "kwargs", ")", ".", "iterrows", "(", ")", "}" ]

[ "Returns", "dictionary", "mapping", "feature", "identifier", "(", "either", "transcript", "or", "gene", "ID", ")", "to", "FPKM", "expression", "value", "." ]

[ "def", "reload", "(", "self", ")", ":", "api", "=", "self", ".", "_instance", ".", "_client", ".", "database_admin_api", "metadata", "=", "_metadata_with_prefix", "(", "self", ".", "name", ")", "response", "=", "api", ".", "get_database_ddl", "(", "self", ".", "name", ",", "metadata", "=", "metadata", ")", "self", ".", "_ddl_statements", "=", "tuple", "(", "response", ".", "statements", ")" ]

[ "Reload", "this", "database", "." ]

[ "def", "is_same_host", "(", "host1", ",", "host2", ")", ":", "try", ":", "if", "host1", "==", "host2", ":", "return", "True", "else", ":", "ips1", "=", "get_host_ips", "(", "host1", ")", "ips2", "=", "get_host_ips", "(", "host2", ")", "return", "len", "(", "set", "(", "ips1", ")", "&", "set", "(", "ips2", ")", ")", ">", "0", "except", "Exception", ",", "ex", ":", "log_exception", "(", "ex", ")", "return", "False" ]

[ "Returns", "true", "if", "host1", "==", "host2", "OR", "map", "to", "the", "same", "host", "(", "using", "DNS", ")" ]

[ "def", "verify_file", "(", "real_source_filename", ",", "real_bytecode_filename", ")", ":", "tempdir", "=", "tempfile", ".", "gettempdir", "(", ")", "source_filename", "=", "os", ".", "path", ".", "join", "(", "tempdir", ",", "\"testing.py\"", ")", "if", "not", "os", ".", "path", ".", "exists", "(", "real_source_filename", ")", ":", "return", "try", ":", "f", "=", "open", "(", "real_source_filename", ",", "'U'", ")", "except", ":", "return", "codestring", "=", "f", ".", "read", "(", ")", "f", ".", "close", "(", ")", "codeobject1", "=", "compile", "(", "codestring", ",", "source_filename", ",", "'exec'", ")", "(", "version", ",", "timestamp", ",", "magic_int", ",", "codeobject2", ",", "is_pypy", ",", "source_size", ")", "=", "load_module", "(", "real_bytecode_filename", ")", "# A hack for PyPy 3.2", "if", "magic_int", "==", "3180", "+", "7", ":", "magic_int", "=", "48", "assert", "MAGIC", "==", "magics", ".", "int2magic", "(", "magic_int", ")", ",", "(", "\"magic_int %d vs %d in %s/%s\"", "%", "(", "magic_int", ",", "magics", ".", "magic2int", "(", "MAGIC", ")", ",", "os", ".", "getcwd", "(", ")", ",", "real_bytecode_filename", ")", ")", "bytecode_filename1", "=", "os", ".", "path", ".", "join", "(", "tempdir", ",", "\"testing1.pyc\"", ")", "dump_compile", "(", "codeobject1", ",", "bytecode_filename1", ",", "timestamp", ",", "MAGIC", ")", "(", "version", ",", "timestamp", ",", "magic_int", ",", "codeobject3", ",", "is_pypy", ",", "source_size", ")", "=", "load_module", "(", "real_bytecode_filename", ",", "fast_load", "=", "not", "is_pypy", ")", "# compare_code(codeobject1, codeobject2)", "# compare_code(codeobject2, codeobject3)", "bytecode_filename2", "=", "os", ".", "path", ".", "join", "(", "tempdir", ",", "\"testing2.pyc\"", ")", "dump_compile", "(", "codeobject1", ",", "bytecode_filename2", ",", "timestamp", ",", "magics", ".", "int2magic", "(", "magic_int", ")", ")", "compare_bytecode_files", "(", "bytecode_filename1", ",", "bytecode_filename2", ")", "return" ]

[ "Compile", "*", "real_source_filename", "*", "using", "the", "running", "Python", "interpreter", ".", "Then", "write", "bytecode", "out", "to", "a", "new", "place", "again", "using", "Python", "s", "routines", "." ]

[ "def", "mmi_to_vrt", "(", "self", ",", "force_flag", "=", "True", ")", ":", "# Ensure the delimited mmi file exists", "LOGGER", ".", "debug", "(", "'mmi_to_vrt requested.'", ")", "vrt_path", "=", "os", ".", "path", ".", "join", "(", "self", ".", "output_dir", ",", "self", ".", "output_basename", "+", "'.vrt'", ")", "# short circuit if the vrt is already created.", "if", "os", ".", "path", ".", "exists", "(", "vrt_path", ")", "and", "force_flag", "is", "not", "True", ":", "return", "vrt_path", "csv_path", "=", "self", ".", "mmi_to_delimited_file", "(", "True", ")", "vrt_string", "=", "(", "'<OGRVRTDataSource>'", "' <OGRVRTLayer name=\"mmi\">'", "' <SrcDataSource>%s</SrcDataSource>'", "' <GeometryType>wkbPoint</GeometryType>'", "' <GeometryField encoding=\"PointFromColumns\"'", "' x=\"lon\" y=\"lat\" z=\"mmi\"/>'", "' </OGRVRTLayer>'", "'</OGRVRTDataSource>'", "%", "csv_path", ")", "with", "codecs", ".", "open", "(", "vrt_path", ",", "'w'", ",", "encoding", "=", "'utf-8'", ")", "as", "f", ":", "f", ".", "write", "(", "vrt_string", ")", "return", "vrt_path" ]

[ "Save", "the", "mmi_data", "to", "an", "ogr", "vrt", "text", "file", "." ]

[ "def", "extractall", "(", "self", ",", "path", "=", "None", ",", "members", "=", "None", ",", "pwd", "=", "None", ")", ":", "if", "members", "is", "None", ":", "members", "=", "self", ".", "namelist", "(", ")", "self", ".", "_extract_members", "(", "members", ",", "path", ",", "pwd", ")" ]

[ "Extract", "all", "members", "from", "the", "archive", "to", "the", "current", "working", "directory", ".", "path", "specifies", "a", "different", "directory", "to", "extract", "to", ".", "members", "is", "optional", "and", "must", "be", "a", "subset", "of", "the", "list", "returned", "by", "namelist", "()", "." ]

[ "def", "who_has", "(", "self", ",", "subid", ")", ":", "answer", "=", "[", "]", "for", "name", "in", "self", ".", "__map", ":", "if", "subid", "in", "self", ".", "__map", "[", "name", "]", "and", "not", "name", "in", "answer", ":", "answer", ".", "append", "(", "name", ")", "return", "answer" ]

[ "Return", "a", "list", "of", "names", "who", "own", "subid", "in", "their", "id", "range", "set", "." ]

[ "def", "init", "(", "self", ",", "attrs", "=", "{", "}", ",", "*", "args", ",", "*", "*", "kwargs", ")", ":", "self", ".", "attrs", "=", "attrs", "self", ".", "preprocess", "(", ")", "self", ".", "convertDict2Attrs", "(", "*", "args", ",", "*", "*", "kwargs", ")", "self", ".", "postprocess", "(", ")", "try", ":", "for", "meth", "in", "kwargs", "[", "'methods'", "]", ":", "try", ":", "getattr", "(", "self", ",", "meth", ")", "(", ")", "except", "Exception", ":", "pass", "except", "Exception", ":", "pass", "try", ":", "for", "propname", ",", "propval", "in", "kwargs", "[", "'properties'", "]", ".", "items", "(", ")", ":", "setattr", "(", "self", ",", "propname", ",", "propval", ")", "except", "Exception", ":", "pass" ]

[ "Default", "initialization", "from", "a", "dictionary", "responded", "by", "Mambu" ]

[ "def", "add_node", "(", "self", ",", "node", ",", "weight", "=", "1", ")", ":", "self", ".", "_nodes", ".", "add", "(", "node", ")", "self", ".", "_weights", "[", "node", "]", "=", "weight", "self", ".", "_hashring", "=", "dict", "(", ")", "self", ".", "_sorted_keys", "=", "[", "]", "self", ".", "_build_circle", "(", ")" ]

[ "Adds", "node", "to", "circle", "and", "rebuild", "it", "." ]

[ "def", "add_widget", "(", "self", ",", "widget", ")", ":", "if", "self", ".", "_buttons", ".", "get", "(", "widget", ")", ":", "return", "btn", "=", "self", ".", "create_button", "(", "widget", ")", "cb", "=", "partial", "(", "self", ".", "focus_widget", ",", "w", "=", "widget", ")", "btn", ".", "clicked", ".", "connect", "(", "cb", ")", "self", ".", "layout", "(", ")", ".", "addWidget", "(", "btn", ")", "self", ".", "_buttons", "[", "widget", "]", "=", "btn" ]

[ "Add", "the", "given", "widget", "to", "the", "tooltip" ]

[ "def", "initialize", "(", "self", ",", "timeouts", ")", ":", "# Bind or connect to address", "if", "self", ".", "bind", "is", "True", ":", "self", ".", "socket", ".", "bind", "(", "self", ".", "address", ")", "else", ":", "self", ".", "socket", ".", "connect", "(", "self", ".", "address", ")", "# Set send and recv timeouts", "self", ".", "_set_timeouts", "(", "timeouts", ")" ]

[ "Bind", "or", "connect", "the", "nanomsg", "socket", "to", "some", "address" ]

[ "def", "_prefetch_items", "(", "self", ",", "change", ")", ":", "if", "self", ".", "is_initialized", ":", "view", "=", "self", ".", "item_view", "upper_limit", "=", "view", ".", "iterable_index", "+", "view", ".", "iterable_fetch_size", "-", "view", ".", "iterable_prefetch", "lower_limit", "=", "max", "(", "0", ",", "view", ".", "iterable_index", "+", "view", ".", "iterable_prefetch", ")", "offset", "=", "int", "(", "view", ".", "iterable_fetch_size", "/", "2.0", ")", "upper_visible_row", "=", "view", ".", "visible_rect", "[", "2", "]", "lower_visible_row", "=", "view", ".", "visible_rect", "[", "0", "]", "print", "(", "\"Visible rect = %s\"", "%", "view", ".", "visible_rect", ")", "if", "upper_visible_row", ">=", "upper_limit", ":", "next_index", "=", "max", "(", "0", ",", "upper_visible_row", "-", "offset", ")", "# Center on current row", "# Going up works... ", "if", "next_index", ">", "view", ".", "iterable_index", ":", "print", "(", "\"Auto prefetch upper limit %s!\"", "%", "upper_limit", ")", "view", ".", "iterable_index", "=", "next_index", "#view.model().reset()", "# But doewn doesnt?", "elif", "view", ".", "iterable_index", ">", "0", "and", "lower_visible_row", "<", "lower_limit", ":", "next_index", "=", "max", "(", "0", ",", "lower_visible_row", "-", "offset", ")", "# Center on current row", "# Going down works", "if", "next_index", "<", "view", ".", "iterable_index", ":", "print", "(", "\"Auto prefetch lower limit=%s, iterable=%s, setting next=%s!\"", "%", "(", "lower_limit", ",", "view", ".", "iterable_index", ",", "next_index", ")", ")", "view", ".", "iterable_index", "=", "next_index" ]

[ "When", "the", "current_row", "in", "the", "model", "changes", "(", "whether", "from", "scrolling", ")", "or", "set", "by", "the", "application", ".", "Make", "sure", "the", "results", "are", "loaded!" ]

[ "def", "create_module_rst_file", "(", "module_name", ")", ":", "return_text", "=", "'Module: '", "+", "module_name", "dash", "=", "'='", "*", "len", "(", "return_text", ")", "return_text", "+=", "'\\n'", "+", "dash", "+", "'\\n\\n'", "return_text", "+=", "'.. automodule:: '", "+", "module_name", "+", "'\\n'", "return_text", "+=", "' :members:\\n\\n'", "return", "return_text" ]

[ "Function", "for", "creating", "content", "in", "each", ".", "rst", "file", "for", "a", "module", "." ]

[ "def", "get_meta", "(", "self", ",", "key", "=", "None", ")", ":", "if", "self", ".", "is_fake", ":", "return", "{", "}", "if", "key", "==", "\"tag\"", ":", "return", "self", ".", "tag", "elif", "key", "is", "None", ":", "ret", "=", "{", "}", "for", "key", "in", "self", ".", "journal", ".", "info", ".", "keys", "(", ")", ":", "ret", "[", "key", "]", "=", "self", ".", "meta_mappings", ".", "map_get", "(", "self", ".", "journal", ".", "info", ",", "key", ")", "[", "1", "]", "return", "ret", "else", ":", "key", ",", "value", "=", "self", ".", "meta_mappings", ".", "map_get", "(", "self", ".", "journal", ".", "info", ",", "key", ")", "return", "value" ]

[ "Get", "metadata", "value", "for", "collection", "." ]

[ "async", "def", "send", "(", "self", ",", "request", ":", "ClientRequest", ",", "*", "*", "kwargs", ":", "Any", ")", "->", "AsyncClientResponse", ":", "# type: ignore", "requests_kwargs", "=", "self", ".", "_configure_send", "(", "request", ",", "*", "*", "kwargs", ")", "return", "await", "super", "(", "AsyncRequestsHTTPSender", ",", "self", ")", ".", "send", "(", "request", ",", "*", "*", "requests_kwargs", ")" ]

[ "Send", "the", "request", "using", "this", "HTTP", "sender", "." ]

[ "def", "register_instance", "(", "self", ",", "class_type", ",", "instance", ",", "register_as", "=", "None", ")", ":", "registration", "=", "_InstanceRegistration", "(", "instance", ")", "self", ".", "_register", "(", "class_type", ",", "registration", ",", "register_as", ")" ]

[ "Registers", "the", "given", "instance", "(", "already", "created", ")", ".", ":", "param", "class_type", ":", "The", "class", "type", ".", ":", "param", "instance", ":", "The", "instance", "to", "register", ".", ":", "param", "register_as", ":", "The", "types", "to", "register", "the", "class", "as", "defaults", "to", "the", "given", "class_type", "." ]

[ "def", "_convert_query", "(", "self", ",", "query", ")", ":", "query", "=", "self", ".", "dictionary", ".", "doc2bow", "(", "self", ".", "_tokenize_latex", "(", "query", ")", ")", "sims", "=", "self", ".", "index", "[", "query", "]", "neighbors", "=", "sorted", "(", "sims", ",", "key", "=", "lambda", "item", ":", "-", "item", "[", "1", "]", ")", "neighbors", "=", "{", "\"neighbors\"", ":", "[", "{", "self", ".", "columns", "[", "0", "]", ":", "{", "\"data\"", ":", "self", ".", "docs", "[", "n", "[", "0", "]", "]", ",", "\"fmt\"", ":", "\"math\"", "}", ",", "self", ".", "columns", "[", "1", "]", ":", "{", "\"data\"", ":", "float", "(", "n", "[", "1", "]", ")", "}", "}", "for", "n", "in", "neighbors", "]", "}", "if", "neighbors", "else", "{", "\"neighbors\"", ":", "[", "]", "}", "return", "neighbors" ]

[ "Convert", "query", "into", "an", "indexable", "string", "." ]

[ "def", "parallel_tfa_lclist", "(", "lclist", ",", "templateinfo", ",", "timecols", "=", "None", ",", "magcols", "=", "None", ",", "errcols", "=", "None", ",", "lcformat", "=", "'hat-sql'", ",", "lcformatdir", "=", "None", ",", "interp", "=", "'nearest'", ",", "sigclip", "=", "5.0", ",", "mintemplatedist_arcmin", "=", "10.0", ",", "nworkers", "=", "NCPUS", ",", "maxworkertasks", "=", "1000", ")", ":", "# open the templateinfo first", "if", "isinstance", "(", "templateinfo", ",", "str", ")", "and", "os", ".", "path", ".", "exists", "(", "templateinfo", ")", ":", "with", "open", "(", "templateinfo", ",", "'rb'", ")", "as", "infd", ":", "templateinfo", "=", "pickle", ".", "load", "(", "infd", ")", "try", ":", "formatinfo", "=", "get_lcformat", "(", "lcformat", ",", "use_lcformat_dir", "=", "lcformatdir", ")", "if", "formatinfo", ":", "(", "dfileglob", ",", "readerfunc", ",", "dtimecols", ",", "dmagcols", ",", "derrcols", ",", "magsarefluxes", ",", "normfunc", ")", "=", "formatinfo", "else", ":", "LOGERROR", "(", "\"can't figure out the light curve format\"", ")", "return", "None", "except", "Exception", "as", "e", ":", "LOGEXCEPTION", "(", "\"can't figure out the light curve format\"", ")", "return", "None", "# override the default timecols, magcols, and errcols", "# using the ones provided to the function", "# we'll get the defaults from the templateinfo object", "if", "timecols", "is", "None", ":", "timecols", "=", "templateinfo", "[", "'timecols'", "]", "if", "magcols", "is", "None", ":", "magcols", "=", "templateinfo", "[", "'magcols'", "]", "if", "errcols", "is", "None", ":", "errcols", "=", "templateinfo", "[", "'errcols'", "]", "outdict", "=", "{", "}", "# run by magcol", "for", "t", ",", "m", ",", "e", "in", "zip", "(", "timecols", ",", "magcols", ",", "errcols", ")", ":", "tasks", "=", "[", "(", "x", ",", "t", ",", "m", ",", "e", ",", "templateinfo", ",", "lcformat", ",", "lcformatdir", ",", "interp", ",", "sigclip", ")", "for", "x", "in", "lclist", "]", "pool", "=", "mp", ".", "Pool", "(", "nworkers", ",", "maxtasksperchild", "=", "maxworkertasks", ")", "results", "=", "pool", ".", "map", "(", "_parallel_tfa_worker", ",", "tasks", ")", "pool", ".", "close", "(", ")", "pool", ".", "join", "(", ")", "outdict", "[", "m", "]", "=", "results", "return", "outdict" ]

[ "This", "applies", "TFA", "in", "parallel", "to", "all", "LCs", "in", "the", "given", "list", "of", "file", "names", "." ]

[ "def", "shorten_text", "(", "text", ":", "str", ")", ":", "if", "len", "(", "text", ")", "<=", "40", ":", "text", "=", "text", "else", ":", "text", "=", "text", "[", ":", "17", "]", "+", "' ... '", "+", "text", "[", "-", "17", ":", "]", "return", "repr", "(", "text", ")" ]

[ "Return", "a", "short", "repr", "of", "text", "if", "it", "is", "longer", "than", "40" ]

[ "def", "stored_bind", "(", "self", ",", "instance", ")", ":", "if", "self", ".", "id", "is", "None", ":", "return", "self", ".", "bind", "(", "instance", ")", "store", "=", "self", ".", "_bound_pangler_store", ".", "setdefault", "(", "instance", ",", "{", "}", ")", "p", "=", "store", ".", "get", "(", "self", ".", "id", ")", "if", "p", "is", "None", ":", "p", "=", "store", "[", "self", ".", "id", "]", "=", "self", ".", "bind", "(", "instance", ")", "return", "p" ]

[ "Bind", "an", "instance", "to", "this", "Pangler", "using", "the", "bound", "Pangler", "store", "." ]

[ "def", "find_one", "(", "self", ",", "tname", ",", "where", "=", "None", ",", "where_not", "=", "None", ",", "columns", "=", "None", ",", "astype", "=", "None", ")", ":", "records", "=", "self", ".", "find", "(", "tname", ",", "where", "=", "where", ",", "where_not", "=", "where_not", ",", "columns", "=", "columns", ",", "astype", "=", "'dataframe'", ")", "return", "self", ".", "_output", "(", "records", ",", "single", "=", "True", ",", "astype", "=", "astype", ")" ]

[ "Find", "a", "single", "record", "in", "the", "provided", "table", "from", "the", "database", ".", "If", "multiple", "match", "return", "the", "first", "one", "based", "on", "the", "internal", "order", "of", "the", "records", ".", "If", "no", "records", "are", "found", "return", "empty", "dictionary", "string", "or", "series", "depending", "on", "the", "value", "of", "astype", "." ]

[ "def", "multiply", "(", "*", "*", "kwargs", ")", ":", "result", "=", "1", "for", "i", "in", "list", "(", "kwargs", ".", "values", "(", ")", ")", ":", "if", "not", "i", ":", "# If one value is null, we return null.", "return", "i", "result", "*=", "i", "return", "result" ]

[ "Simple", "postprocessor", "where", "we", "multiply", "the", "input", "values", "." ]

[ "def", "union", "(", "self", ",", "other", ")", ":", "if", "isinstance", "(", "other", ",", "self", ".", "__class__", ")", ":", "return", "self", ".", "client", ".", "sunion", "(", "[", "self", ".", "name", ",", "other", ".", "name", "]", ")", "else", ":", "return", "self", ".", "_as_set", "(", ")", ".", "union", "(", "other", ")" ]

[ "Return", "the", "union", "of", "sets", "as", "a", "new", "set", "." ]

[ "def", "string", "(", "self", ")", "->", "bytes", ":", "if", "self", ".", "_raw", "is", "not", "None", ":", "return", "self", ".", "_raw", "self", ".", "_raw", "=", "raw", "=", "BytesFormat", "(", "b' '", ")", ".", "join", "(", "[", "b'CAPABILITY'", ",", "b'IMAP4rev1'", "]", "+", "self", ".", "capabilities", ")", "return", "raw" ]

[ "The", "capabilities", "string", "without", "the", "enclosing", "square", "brackets", "." ]

[ "def", "get_csv_reader", "(", "csvfile", ",", "dialect", "=", "csv", ".", "excel", ",", "encoding", "=", "\"utf-8\"", ",", "*", "*", "kwds", ")", ":", "try", ":", "# pylint: disable=pointless-statement", "unicode", "return", "UnicodeReader", "(", "csvfile", ",", "dialect", "=", "dialect", ",", "encoding", "=", "encoding", ",", "*", "*", "kwds", ")", "except", "NameError", ":", "return", "csv", ".", "reader", "(", "csvfile", ",", "dialect", "=", "dialect", ",", "*", "*", "kwds", ")" ]

[ "Returns", "csv", "reader", "." ]

[ "def", "pan_pan_cb", "(", "self", ",", "fitsimage", ",", "event", ")", ":", "chviewer", "=", "self", ".", "fv", ".", "getfocus_viewer", "(", ")", "bd", "=", "chviewer", ".", "get_bindings", "(", ")", "if", "hasattr", "(", "bd", ",", "'pa_pan'", ")", ":", "return", "bd", ".", "pa_pan", "(", "chviewer", ",", "event", ")", "return", "False" ]

[ "Pan", "event", "in", "the", "pan", "window", ".", "Just", "pan", "the", "channel", "viewer", "." ]

[ "def", "readlines", "(", "filepath", ")", ":", "with", "open", "(", "filepath", ",", "'rt'", ")", "as", "f", ":", "lines", "=", "f", ".", "readlines", "(", ")", "lines", "=", "map", "(", "str", ".", "strip", ",", "lines", ")", "lines", "=", "[", "l", "for", "l", "in", "lines", "if", "l", "]", "return", "lines" ]

[ "read", "lines", "from", "a", "textfile", ":", "param", "filepath", ":", ":", "return", ":", "list", "[", "line", "]" ]

[ "def", "iplot_hys", "(", "fignum", ",", "B", ",", "M", ",", "s", ")", ":", "if", "fignum", "!=", "0", ":", "plt", ".", "figure", "(", "num", "=", "fignum", ")", "plt", ".", "clf", "(", ")", "hpars", "=", "{", "}", "# close up loop", "Npts", "=", "len", "(", "M", ")", "B70", "=", "0.7", "*", "B", "[", "0", "]", "# 70 percent of maximum field", "for", "b", "in", "B", ":", "if", "b", "<", "B70", ":", "break", "Nint", "=", "B", ".", "index", "(", "b", ")", "-", "1", "if", "Nint", ">", "30", ":", "Nint", "=", "30", "if", "Nint", "<", "10", ":", "Nint", "=", "10", "Bzero", ",", "Mzero", ",", "Mfix", ",", "Mnorm", ",", "Madj", ",", "MadjN", "=", "\"\"", ",", "\"\"", ",", "[", "]", ",", "[", "]", ",", "[", "]", ",", "[", "]", "Mazero", "=", "\"\"", "m_init", "=", "0.5", "*", "(", "M", "[", "0", "]", "+", "M", "[", "1", "]", ")", "m_fin", "=", "0.5", "*", "(", "M", "[", "-", "1", "]", "+", "M", "[", "-", "2", "]", ")", "diff", "=", "m_fin", "-", "m_init", "Bmin", "=", "0.", "for", "k", "in", "range", "(", "Npts", ")", ":", "frac", "=", "old_div", "(", "float", "(", "k", ")", ",", "float", "(", "Npts", "-", "1", ")", ")", "Mfix", ".", "append", "(", "(", "M", "[", "k", "]", "-", "diff", "*", "frac", ")", ")", "if", "Bzero", "==", "\"\"", "and", "B", "[", "k", "]", "<", "0", ":", "Bzero", "=", "k", "if", "B", "[", "k", "]", "<", "Bmin", ":", "Bmin", "=", "B", "[", "k", "]", "kmin", "=", "k", "# adjust slope with first 30 data points (throwing out first 3)", "Bslop", "=", "B", "[", "2", ":", "Nint", "+", "2", "]", "Mslop", "=", "Mfix", "[", "2", ":", "Nint", "+", "2", "]", "polyU", "=", "polyfit", "(", "Bslop", ",", "Mslop", ",", "1", ")", "# best fit line to high field points", "# adjust slope with first 30 points of ascending branch", "Bslop", "=", "B", "[", "kmin", ":", "kmin", "+", "(", "Nint", "+", "1", ")", "]", "Mslop", "=", "Mfix", "[", "kmin", ":", "kmin", "+", "(", "Nint", "+", "1", ")", "]", "polyL", "=", "polyfit", "(", "Bslop", ",", "Mslop", ",", "1", ")", "# best fit line to high field points", "xhf", "=", "0.5", "*", "(", "polyU", "[", "0", "]", "+", "polyL", "[", "0", "]", ")", "# mean of two slopes", "# convert B to A/m, high field slope in m^3", "hpars", "[", "'hysteresis_xhf'", "]", "=", "'%8.2e'", "%", "(", "xhf", "*", "4", "*", "np", ".", "pi", "*", "1e-7", ")", "meanint", "=", "0.5", "*", "(", "polyU", "[", "1", "]", "+", "polyL", "[", "1", "]", ")", "# mean of two intercepts", "Msat", "=", "0.5", "*", "(", "polyU", "[", "1", "]", "-", "polyL", "[", "1", "]", ")", "# mean of saturation remanence", "Moff", "=", "[", "]", "for", "k", "in", "range", "(", "Npts", ")", ":", "# take out linear slope and offset (makes symmetric about origin)", "Moff", ".", "append", "(", "(", "Mfix", "[", "k", "]", "-", "xhf", "*", "B", "[", "k", "]", "-", "meanint", ")", ")", "if", "Mzero", "==", "\"\"", "and", "Moff", "[", "k", "]", "<", "0", ":", "Mzero", "=", "k", "if", "Mzero", "!=", "\"\"", "and", "Mazero", "==", "\"\"", "and", "Moff", "[", "k", "]", ">", "0", ":", "Mazero", "=", "k", "hpars", "[", "'hysteresis_ms_moment'", "]", "=", "'%8.3e'", "%", "(", "Msat", ")", "# Ms in Am^2", "#", "# split into upper and lower loops for splining", "Mupper", ",", "Bupper", ",", "Mlower", ",", "Blower", "=", "[", "]", ",", "[", "]", ",", "[", "]", ",", "[", "]", "deltaM", ",", "Bdm", "=", "[", "]", ",", "[", "]", "# diff between upper and lower curves at Bdm", "for", "k", "in", "range", "(", "kmin", "-", "2", ",", "0", ",", "-", "2", ")", ":", "Mupper", ".", "append", "(", "old_div", "(", "Moff", "[", "k", "]", ",", "Msat", ")", ")", "Bupper", ".", "append", "(", "B", "[", "k", "]", ")", "for", "k", "in", "range", "(", "kmin", "+", "2", ",", "len", "(", "B", ")", "-", "1", ")", ":", "Mlower", ".", "append", "(", "Moff", "[", "k", "]", "/", "Msat", ")", "Blower", ".", "append", "(", "B", "[", "k", "]", ")", "Iupper", "=", "spline", ".", "Spline", "(", "Bupper", ",", "Mupper", ")", "# get splines for upper up and down", "Ilower", "=", "spline", ".", "Spline", "(", "Blower", ",", "Mlower", ")", "# get splines for lower", "for", "b", "in", "np", ".", "arange", "(", "B", "[", "0", "]", ")", ":", "# get range of field values", "Mpos", "=", "(", "(", "Iupper", "(", "b", ")", "-", "Ilower", "(", "b", ")", ")", ")", "# evaluate on both sides of B", "Mneg", "=", "(", "(", "Iupper", "(", "-", "b", ")", "-", "Ilower", "(", "-", "b", ")", ")", ")", "Bdm", ".", "append", "(", "b", ")", "deltaM", ".", "append", "(", "0.5", "*", "(", "Mpos", "+", "Mneg", ")", ")", "# take average delta M", "print", "(", "'whew'", ")", "for", "k", "in", "range", "(", "Npts", ")", ":", "MadjN", ".", "append", "(", "old_div", "(", "Moff", "[", "k", "]", ",", "Msat", ")", ")", "Mnorm", ".", "append", "(", "old_div", "(", "M", "[", "k", "]", ",", "Msat", ")", ")", "# find Mr : average of two spline fits evaluted at B=0 (times Msat)", "Mr", "=", "Msat", "*", "0.5", "*", "(", "Iupper", "(", "0.", ")", "-", "Ilower", "(", "0.", ")", ")", "hpars", "[", "'hysteresis_mr_moment'", "]", "=", "'%8.3e'", "%", "(", "Mr", ")", "# find Bc (x intercept), interpolate between two bounding points", "Bz", "=", "B", "[", "Mzero", "-", "1", ":", "Mzero", "+", "1", "]", "Mz", "=", "Moff", "[", "Mzero", "-", "1", ":", "Mzero", "+", "1", "]", "Baz", "=", "B", "[", "Mazero", "-", "1", ":", "Mazero", "+", "1", "]", "Maz", "=", "Moff", "[", "Mazero", "-", "1", ":", "Mazero", "+", "1", "]", "try", ":", "poly", "=", "polyfit", "(", "Bz", ",", "Mz", ",", "1", ")", "# best fit line through two bounding points", "Bc", "=", "old_div", "(", "-", "poly", "[", "1", "]", ",", "poly", "[", "0", "]", ")", "# x intercept", "# best fit line through two bounding points", "poly", "=", "polyfit", "(", "Baz", ",", "Maz", ",", "1", ")", "Bac", "=", "old_div", "(", "-", "poly", "[", "1", "]", ",", "poly", "[", "0", "]", ")", "# x intercept", "hpars", "[", "'hysteresis_bc'", "]", "=", "'%8.3e'", "%", "(", "0.5", "*", "(", "abs", "(", "Bc", ")", "+", "abs", "(", "Bac", ")", ")", ")", "except", ":", "hpars", "[", "'hysteresis_bc'", "]", "=", "'0'", "return", "hpars", ",", "deltaM", ",", "Bdm", ",", "B", ",", "Mnorm", ",", "MadjN" ]

[ "function", "to", "plot", "hysteresis", "data" ]

[ "def", "weight_unit", "(", "self", ",", "weight_unit", ")", ":", "allowed_values", "=", "[", "\"pound\"", ",", "\"kilogram\"", "]", "# noqa: E501", "if", "weight_unit", "is", "not", "None", "and", "weight_unit", "not", "in", "allowed_values", ":", "raise", "ValueError", "(", "\"Invalid value for `weight_unit` ({0}), must be one of {1}\"", "# noqa: E501", ".", "format", "(", "weight_unit", ",", "allowed_values", ")", ")", "self", ".", "_weight_unit", "=", "weight_unit" ]

[ "Sets", "the", "weight_unit", "of", "this", "MeasurementSettings", "." ]

[ "def", "write", "(", "self", ",", "file_path", ")", ":", "if", "self", ".", "__samples", "is", "None", ":", "if", "self", ".", "file_path", "is", "None", ":", "self", ".", "log_exc", "(", "u\"AudioFile object not initialized\"", ",", "None", ",", "True", ",", "AudioFileNotInitializedError", ")", "else", ":", "self", ".", "read_samples_from_file", "(", ")", "self", ".", "log", "(", "[", "u\"Writing audio file '%s'...\"", ",", "file_path", "]", ")", "try", ":", "# our value is a float64 in [-1, 1]", "# scipy writes the sample as an int16_t, that is, a number in [-32768, 32767]", "data", "=", "(", "self", ".", "audio_samples", "*", "32768", ")", ".", "astype", "(", "\"int16\"", ")", "scipywavwrite", "(", "file_path", ",", "self", ".", "audio_sample_rate", ",", "data", ")", "except", "Exception", "as", "exc", ":", "self", ".", "log_exc", "(", "u\"Error writing audio file to '%s'\"", "%", "(", "file_path", ")", ",", "exc", ",", "True", ",", "OSError", ")", "self", ".", "log", "(", "[", "u\"Writing audio file '%s'... done\"", ",", "file_path", "]", ")" ]

[ "Write", "the", "audio", "data", "to", "file", ".", "Return", "True", "on", "success", "or", "False", "otherwise", "." ]

[ "def", "log_folder_setup", "(", "log_path", ",", "archive_logs", "=", "False", ")", ":", "if", "log_path", ".", "endswith", "(", "\"/\"", ")", ":", "log_path", "=", "log_path", "[", ":", "-", "1", "]", "if", "not", "os", ".", "path", ".", "exists", "(", "log_path", ")", ":", "try", ":", "os", ".", "makedirs", "(", "log_path", ")", "except", "Exception", ":", "pass", "# Should only be reachable during multi-threaded runs", "else", ":", "archived_folder", "=", "\"%s/../archived_logs/\"", "%", "log_path", "if", "not", "os", ".", "path", ".", "exists", "(", "archived_folder", ")", ":", "try", ":", "os", ".", "makedirs", "(", "archived_folder", ")", "except", "Exception", ":", "pass", "# Should only be reachable during multi-threaded runs", "if", "not", "\"\"", ".", "join", "(", "sys", ".", "argv", ")", "==", "\"-c\"", ":", "# Only move log files if the test run is not multi-threaded.", "# (Running tests with \"-n NUM\" will create threads that only", "# have \"-c\" in the sys.argv list. Easy to catch.)", "archived_logs", "=", "\"%slogs_%s\"", "%", "(", "archived_folder", ",", "int", "(", "time", ".", "time", "(", ")", ")", ")", "shutil", ".", "move", "(", "log_path", ",", "archived_logs", ")", "os", ".", "makedirs", "(", "log_path", ")", "if", "not", "settings", ".", "ARCHIVE_EXISTING_LOGS", "and", "not", "archive_logs", ":", "shutil", ".", "rmtree", "(", "archived_logs", ")" ]

[ "Handle", "Logging" ]