Datasets:

---

kejian

/

codesearchnet-python-raw

like 1

[ "def", "route_filter_rules", "(", "self", ")", ":", "api_version", "=", "self", ".", "_get_api_version", "(", "'route_filter_rules'", ")", "if", "api_version", "==", "'2016-12-01'", ":", "from", ".", "v2016_12_01", ".", "operations", "import", "RouteFilterRulesOperations", "as", "OperationClass", "elif", "api_version", "==", "'2017-03-01'", ":", "from", ".", "v2017_03_01", ".", "operations", "import", "RouteFilterRulesOperations", "as", "OperationClass", "elif", "api_version", "==", "'2017-06-01'", ":", "from", ".", "v2017_06_01", ".", "operations", "import", "RouteFilterRulesOperations", "as", "OperationClass", "elif", "api_version", "==", "'2017-08-01'", ":", "from", ".", "v2017_08_01", ".", "operations", "import", "RouteFilterRulesOperations", "as", "OperationClass", "elif", "api_version", "==", "'2017-09-01'", ":", "from", ".", "v2017_09_01", ".", "operations", "import", "RouteFilterRulesOperations", "as", "OperationClass", "elif", "api_version", "==", "'2017-10-01'", ":", "from", ".", "v2017_10_01", ".", "operations", "import", "RouteFilterRulesOperations", "as", "OperationClass", "elif", "api_version", "==", "'2017-11-01'", ":", "from", ".", "v2017_11_01", ".", "operations", "import", "RouteFilterRulesOperations", "as", "OperationClass", "elif", "api_version", "==", "'2018-01-01'", ":", "from", ".", "v2018_01_01", ".", "operations", "import", "RouteFilterRulesOperations", "as", "OperationClass", "elif", "api_version", "==", "'2018-02-01'", ":", "from", ".", "v2018_02_01", ".", "operations", "import", "RouteFilterRulesOperations", "as", "OperationClass", "elif", "api_version", "==", "'2018-04-01'", ":", "from", ".", "v2018_04_01", ".", "operations", "import", "RouteFilterRulesOperations", "as", "OperationClass", "elif", "api_version", "==", "'2018-06-01'", ":", "from", ".", "v2018_06_01", ".", "operations", "import", "RouteFilterRulesOperations", "as", "OperationClass", "elif", "api_version", "==", "'2018-07-01'", ":", "from", ".", "v2018_07_01", ".", "operations", "import", "RouteFilterRulesOperations", "as", "OperationClass", "elif", "api_version", "==", "'2018-08-01'", ":", "from", ".", "v2018_08_01", ".", "operations", "import", "RouteFilterRulesOperations", "as", "OperationClass", "else", ":", "raise", "NotImplementedError", "(", "\"APIVersion {} is not available\"", ".", "format", "(", "api_version", ")", ")", "return", "OperationClass", "(", "self", ".", "_client", ",", "self", ".", "config", ",", "Serializer", "(", "self", ".", "_models_dict", "(", "api_version", ")", ")", ",", "Deserializer", "(", "self", ".", "_models_dict", "(", "api_version", ")", ")", ")" ]

[ "Instance", "depends", "on", "the", "API", "version", ":" ]

[ "def", "ensure_exists", "(", "p", ",", "assume_dirs", "=", "False", ")", ":", "if", "path", "(", "p", ")", ".", "ext", "and", "not", "assume_dirs", ":", "path", "(", "p", ")", ".", "dirname", "(", ")", ".", "makedirs_p", "(", ")", "else", ":", "path", "(", "p", ")", ".", "makedirs_p", "(", ")", "return", "p" ]

[ "Ensures", "a", "given", "path", "*", "p", "*", "exists", "." ]

[ "def", "import_locations", "(", "self", ",", "baken_file", ")", ":", "self", ".", "_baken_file", "=", "baken_file", "data", "=", "ConfigParser", "(", ")", "if", "hasattr", "(", "baken_file", ",", "'readlines'", ")", ":", "data", ".", "readfp", "(", "baken_file", ")", "elif", "isinstance", "(", "baken_file", ",", "list", ")", ":", "data", ".", "read", "(", "baken_file", ")", "elif", "isinstance", "(", "baken_file", ",", "basestring", ")", ":", "data", ".", "readfp", "(", "open", "(", "baken_file", ")", ")", "else", ":", "raise", "TypeError", "(", "'Unable to handle data of type %r'", "%", "type", "(", "baken_file", ")", ")", "valid_locator", "=", "re", ".", "compile", "(", "r\"[A-Z]{2}\\d{2}[A-Z]{2}\"", ")", "for", "name", "in", "data", ".", "sections", "(", ")", ":", "elements", "=", "{", "}", "for", "item", "in", "(", "'latitude'", ",", "'longitude'", ",", "'antenna'", ",", "'direction'", ",", "'frequency'", ",", "'height'", ",", "'locator'", ",", "'mode'", ",", "'operator'", ",", "'power'", ",", "'qth'", ")", ":", "if", "data", ".", "has_option", "(", "name", ",", "item", ")", ":", "if", "item", "in", "(", "'antenna'", ",", "'locator'", ",", "'mode'", ",", "'power'", ",", "'qth'", ")", ":", "elements", "[", "item", "]", "=", "data", ".", "get", "(", "name", ",", "item", ")", "elif", "item", "==", "'operator'", ":", "elements", "[", "item", "]", "=", "elements", "[", "item", "]", ".", "split", "(", "','", ")", "elif", "item", "==", "'direction'", ":", "elements", "[", "item", "]", "=", "data", ".", "get", "(", "name", ",", "item", ")", ".", "split", "(", "','", ")", "else", ":", "try", ":", "elements", "[", "item", "]", "=", "data", ".", "getfloat", "(", "name", ",", "item", ")", "except", "ValueError", ":", "logging", ".", "debug", "(", "'Multiple frequency workaround for '", "'%r entry'", "%", "name", ")", "elements", "[", "item", "]", "=", "map", "(", "float", ",", "data", ".", "get", "(", "name", ",", "item", ")", ".", "split", "(", "','", ")", ")", "else", ":", "elements", "[", "item", "]", "=", "None", "if", "elements", "[", "'latitude'", "]", "is", "None", "and", "not", "valid_locator", ".", "match", "(", "elements", "[", "'locator'", "]", ")", ":", "logging", ".", "info", "(", "'Skipping %r entry, as it contains no location '", "'data'", "%", "name", ")", "continue", "self", "[", "name", "]", "=", "Baken", "(", "*", "*", "elements", ")" ]

[ "Import", "baken", "data", "files", "." ]

[ "def", "wtime_to_minutes", "(", "time_string", ")", ":", "hours", ",", "mins", ",", "seconds", "=", "time_string", ".", "split", "(", "':'", ")", "return", "int", "(", "hours", ")", "*", "60", "+", "int", "(", "mins", ")", "+", "1" ]

[ "wtime_to_minutes" ]

[ "def", "check_list_type", "(", "objects", ",", "allowed_type", ",", "name", ",", "allow_none", "=", "True", ")", ":", "if", "objects", "is", "None", ":", "if", "not", "allow_none", ":", "raise", "TypeError", "(", "'%s is None, which is not allowed.'", "%", "name", ")", "return", "objects", "if", "not", "isinstance", "(", "objects", ",", "(", "tuple", ",", "list", ")", ")", ":", "raise", "TypeError", "(", "'%s is not a list.'", "%", "name", ")", "if", "not", "all", "(", "isinstance", "(", "i", ",", "allowed_type", ")", "for", "i", "in", "objects", ")", ":", "type_list", "=", "sorted", "(", "list", "(", "set", "(", "type", "(", "obj", ")", "for", "obj", "in", "objects", ")", ")", ")", "raise", "TypeError", "(", "'%s contains types that don\\'t match %s: %s'", "%", "(", "name", ",", "allowed_type", ".", "__name__", ",", "type_list", ")", ")", "return", "objects" ]

[ "Verify", "that", "objects", "in", "list", "are", "of", "the", "allowed", "type", "or", "raise", "TypeError", "." ]

[ "def", "__decode_dictionary", "(", "self", ",", "message_type", ",", "dictionary", ")", ":", "message", "=", "message_type", "(", ")", "for", "key", ",", "value", "in", "six", ".", "iteritems", "(", "dictionary", ")", ":", "if", "value", "is", "None", ":", "try", ":", "message", ".", "reset", "(", "key", ")", "except", "AttributeError", ":", "pass", "# This is an unrecognized field, skip it.", "continue", "try", ":", "field", "=", "message", ".", "field_by_name", "(", "key", ")", "except", "KeyError", ":", "# Save unknown values.", "variant", "=", "self", ".", "__find_variant", "(", "value", ")", "if", "variant", ":", "message", ".", "set_unrecognized_field", "(", "key", ",", "value", ",", "variant", ")", "continue", "if", "field", ".", "repeated", ":", "# This should be unnecessary? Or in fact become an error.", "if", "not", "isinstance", "(", "value", ",", "list", ")", ":", "value", "=", "[", "value", "]", "valid_value", "=", "[", "self", ".", "decode_field", "(", "field", ",", "item", ")", "for", "item", "in", "value", "]", "setattr", "(", "message", ",", "field", ".", "name", ",", "valid_value", ")", "continue", "# This is just for consistency with the old behavior.", "if", "value", "==", "[", "]", ":", "continue", "try", ":", "setattr", "(", "message", ",", "field", ".", "name", ",", "self", ".", "decode_field", "(", "field", ",", "value", ")", ")", "except", "messages", ".", "DecodeError", ":", "# Save unknown enum values.", "if", "not", "isinstance", "(", "field", ",", "messages", ".", "EnumField", ")", ":", "raise", "variant", "=", "self", ".", "__find_variant", "(", "value", ")", "if", "variant", ":", "message", ".", "set_unrecognized_field", "(", "key", ",", "value", ",", "variant", ")", "return", "message" ]

[ "Merge", "dictionary", "in", "to", "message", "." ]

[ "def", "check_response", "(", "self", ",", "response", ")", ":", "if", "response", ".", "status_code", "==", "401", ":", "raise", "D4S2Error", "(", "UNAUTHORIZED_MESSAGE", ")", "if", "not", "200", "<=", "response", ".", "status_code", "<", "300", ":", "raise", "D4S2Error", "(", "\"Request to {} failed with {}:\\n{}.\"", ".", "format", "(", "response", ".", "url", ",", "response", ".", "status_code", ",", "response", ".", "text", ")", ")" ]

[ "Raises", "error", "if", "the", "response", "isn", "t", "successful", ".", ":", "param", "response", ":", "requests", ".", "Response", "response", "to", "be", "checked" ]

[ "def", "_code_search", "(", "query", ",", "github_user", "=", "None", ")", ":", "github_client", "=", "temple", ".", "utils", ".", "GithubClient", "(", ")", "headers", "=", "{", "'Accept'", ":", "'application/vnd.github.v3.text-match+json'", "}", "resp", "=", "github_client", ".", "get", "(", "'/search/code'", ",", "params", "=", "{", "'q'", ":", "query", ",", "'per_page'", ":", "100", "}", ",", "headers", "=", "headers", ")", "if", "resp", ".", "status_code", "==", "requests", ".", "codes", ".", "unprocessable_entity", "and", "github_user", ":", "raise", "temple", ".", "exceptions", ".", "InvalidGithubUserError", "(", "'Invalid Github user or org - \"{}\"'", ".", "format", "(", "github_user", ")", ")", "resp", ".", "raise_for_status", "(", ")", "resp_data", "=", "resp", ".", "json", "(", ")", "repositories", "=", "collections", ".", "defaultdict", "(", "dict", ")", "while", "True", ":", "repositories", ".", "update", "(", "{", "'[email protected]:{}.git'", ".", "format", "(", "repo", "[", "'repository'", "]", "[", "'full_name'", "]", ")", ":", "repo", "[", "'repository'", "]", "for", "repo", "in", "resp_data", "[", "'items'", "]", "}", ")", "next_url", "=", "_parse_link_header", "(", "resp", ".", "headers", ")", ".", "get", "(", "'next'", ")", "if", "next_url", ":", "resp", "=", "requests", ".", "get", "(", "next_url", ",", "headers", "=", "headers", ")", "resp", ".", "raise_for_status", "(", ")", "resp_data", "=", "resp", ".", "json", "(", ")", "else", ":", "break", "return", "repositories" ]

[ "Performs", "a", "Github", "API", "code", "search" ]

[ "def", "fromxldate", "(", "xldate", ",", "datemode", "=", "1", ")", ":", "t", "=", "xlrd", ".", "xldate_as_tuple", "(", "xldate", ",", "datemode", ")", "return", "datetime", ".", "datetime", "(", "*", "t", ")" ]

[ "Return", "a", "python", "datetime", "object" ]

[ "def", "flush", "(", "self", ")", ":", "if", "not", "self", ".", "items", ":", "return", "retry", "=", "0", "options", "=", "{", "\"deadline\"", ":", "DATASTORE_DEADLINE", "}", "while", "retry", "<=", "self", ".", "__timeout_retries", ":", "try", ":", "self", ".", "__flush_function", "(", "self", ".", "items", ",", "options", ")", "self", ".", "clear", "(", ")", "break", "except", "db", ".", "Timeout", ",", "e", ":", "logging", ".", "warning", "(", "e", ")", "logging", ".", "warning", "(", "\"Flushing '%s' timed out. Will retry for the %s time.\"", ",", "self", ",", "retry", ")", "retry", "+=", "1", "options", "[", "\"deadline\"", "]", "*=", "2", "except", "apiproxy_errors", ".", "RequestTooLargeError", ":", "self", ".", "_log_largest_items", "(", ")", "raise", "else", ":", "raise" ]

[ "Force", "a", "flush", "." ]

[ "def", "encode", "(", "self", ",", "obj", ")", ":", "if", "isinstance", "(", "obj", ",", "int_like_types", ")", ":", "self", ".", "result", ".", "append", "(", "\"i%de\"", "%", "obj", ")", "elif", "isinstance", "(", "obj", ",", "string_types", ")", ":", "self", ".", "result", ".", "extend", "(", "[", "str", "(", "len", "(", "obj", ")", ")", ",", "':'", ",", "str", "(", "obj", ")", "]", ")", "elif", "hasattr", "(", "obj", ",", "\"__bencode__\"", ")", ":", "self", ".", "encode", "(", "obj", ".", "__bencode__", "(", ")", ")", "elif", "hasattr", "(", "obj", ",", "\"items\"", ")", ":", "# Dictionary", "self", ".", "result", ".", "append", "(", "'d'", ")", "for", "key", ",", "val", "in", "sorted", "(", "obj", ".", "items", "(", ")", ")", ":", "key", "=", "str", "(", "key", ")", "self", ".", "result", ".", "extend", "(", "[", "str", "(", "len", "(", "key", ")", ")", ",", "':'", ",", "key", "]", ")", "self", ".", "encode", "(", "val", ")", "self", ".", "result", ".", "append", "(", "'e'", ")", "else", ":", "# Treat as iterable", "try", ":", "items", "=", "iter", "(", "obj", ")", "except", "TypeError", "as", "exc", ":", "raise", "BencodeError", "(", "\"Unsupported non-iterable object %r of type %s (%s)\"", "%", "(", "obj", ",", "type", "(", "obj", ")", ",", "exc", ")", ")", "else", ":", "self", ".", "result", ".", "append", "(", "'l'", ")", "for", "item", "in", "items", ":", "self", ".", "encode", "(", "item", ")", "self", ".", "result", ".", "append", "(", "'e'", ")", "return", "self", ".", "result" ]

[ "Add", "the", "given", "object", "to", "the", "result", "." ]

[ "def", "count", "(", "self", ")", ":", "return", "functools", ".", "reduce", "(", "lambda", "x", ",", "y", ":", "x", "*", "y", ",", "(", "x", ".", "count", "for", "x", "in", "self", ".", "bounds", ")", ")" ]

[ "Total", "number", "of", "array", "cells" ]

[ "def", "from_blob", "(", "cls", ",", "blob", ",", "stage", "=", "0", ")", ":", "time", "=", "pack", "(", "\">LL\"", ",", "0", ",", "0", ")", "return", "IndexEntry", "(", "(", "blob", ".", "mode", ",", "blob", ".", "binsha", ",", "stage", "<<", "CE_STAGESHIFT", ",", "blob", ".", "path", ",", "time", ",", "time", ",", "0", ",", "0", ",", "0", ",", "0", ",", "blob", ".", "size", ")", ")" ]

[ ":", "return", ":", "Minimal", "entry", "resembling", "the", "given", "blob", "object" ]

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

[ "Sets", "the", "display", "of", "this", "Message", "." ]

[ "def", "showEditor", "(", "self", ")", ":", "if", "self", ".", "editor", "is", "not", "None", ":", "editor", "=", "self", ".", "editor", "(", ")", "editor", ".", "setModel", "(", "self", ")", "factory", "=", "get_stimulus_factory", "(", "self", ".", "_stim", ".", "stimType", "(", ")", ")", "editor", ".", "editingFinished", ".", "connect", "(", "factory", ".", "update", ")", "return", "editor", "else", ":", "logger", "=", "logging", ".", "getLogger", "(", "'main'", ")", "logger", ".", "warning", "(", "'Erm, no editor available :('", ")" ]

[ "Creates", "and", "shows", "an", "editor", "for", "this", "Stimulus" ]

[ "def", "is_child_of_objective_bank", "(", "self", ",", "id_", ",", "objective_bank_id", ")", ":", "# Implemented from template for", "# osid.resource.BinHierarchySession.is_child_of_bin", "if", "self", ".", "_catalog_session", "is", "not", "None", ":", "return", "self", ".", "_catalog_session", ".", "is_child_of_catalog", "(", "id_", "=", "id_", ",", "catalog_id", "=", "objective_bank_id", ")", "return", "self", ".", "_hierarchy_session", ".", "is_child", "(", "id_", "=", "objective_bank_id", ",", "child_id", "=", "id_", ")" ]

[ "Tests", "if", "an", "objective", "bank", "is", "a", "direct", "child", "of", "another", "." ]

[ "def", "make_pdf_from_html", "(", "# Mandatory parameters:", "on_disk", ":", "bool", ",", "html", ":", "str", ",", "# Disk options:", "output_path", ":", "str", "=", "None", ",", "# Shared options:", "header_html", ":", "str", "=", "None", ",", "footer_html", ":", "str", "=", "None", ",", "wkhtmltopdf_filename", ":", "str", "=", "_WKHTMLTOPDF_FILENAME", ",", "wkhtmltopdf_options", ":", "Dict", "[", "str", ",", "Any", "]", "=", "None", ",", "file_encoding", ":", "str", "=", "\"utf-8\"", ",", "debug_options", ":", "bool", "=", "False", ",", "debug_content", ":", "bool", "=", "False", ",", "debug_wkhtmltopdf_args", ":", "bool", "=", "True", ",", "fix_pdfkit_encoding_bug", ":", "bool", "=", "None", ",", "processor", ":", "str", "=", "_DEFAULT_PROCESSOR", ")", "->", "Union", "[", "bytes", ",", "bool", "]", ":", "wkhtmltopdf_options", "=", "wkhtmltopdf_options", "or", "{", "}", "# type: Dict[str, Any]", "assert_processor_available", "(", "processor", ")", "if", "debug_content", ":", "log", ".", "debug", "(", "\"html: {}\"", ",", "html", ")", "log", ".", "debug", "(", "\"header_html: {}\"", ",", "header_html", ")", "log", ".", "debug", "(", "\"footer_html: {}\"", ",", "footer_html", ")", "if", "fix_pdfkit_encoding_bug", "is", "None", ":", "fix_pdfkit_encoding_bug", "=", "get_default_fix_pdfkit_encoding_bug", "(", ")", "if", "processor", "==", "Processors", ".", "XHTML2PDF", ":", "if", "on_disk", ":", "with", "open", "(", "output_path", ",", "mode", "=", "'wb'", ")", "as", "outfile", ":", "# noinspection PyUnresolvedReferences", "xhtml2pdf", ".", "document", ".", "pisaDocument", "(", "html", ",", "outfile", ")", "return", "True", "else", ":", "memfile", "=", "io", ".", "BytesIO", "(", ")", "# noinspection PyUnresolvedReferences", "xhtml2pdf", ".", "document", ".", "pisaDocument", "(", "html", ",", "memfile", ")", "# ... returns a document, but we don't use it, so we don't store it", "# to stop pychecker complaining", "# http://xhtml2pdf.appspot.com/static/pisa-en.html", "memfile", ".", "seek", "(", "0", ")", "return", "memfile", ".", "read", "(", ")", "# http://stackoverflow.com/questions/3310584", "elif", "processor", "==", "Processors", ".", "WEASYPRINT", ":", "if", "on_disk", ":", "return", "weasyprint", ".", "HTML", "(", "string", "=", "html", ")", ".", "write_pdf", "(", "output_path", ")", "else", ":", "# http://ampad.de/blog/generating-pdfs-django/", "return", "weasyprint", ".", "HTML", "(", "string", "=", "html", ")", ".", "write_pdf", "(", ")", "elif", "processor", "==", "Processors", ".", "PDFKIT", ":", "# Config:", "if", "not", "wkhtmltopdf_filename", ":", "config", "=", "None", "else", ":", "if", "fix_pdfkit_encoding_bug", ":", "# needs to be True for pdfkit==0.5.0", "log", ".", "debug", "(", "\"Attempting to fix bug in pdfkit (e.g. version 0.5.0)\"", "\" by encoding wkhtmltopdf_filename to UTF-8\"", ")", "config", "=", "pdfkit", ".", "configuration", "(", "wkhtmltopdf", "=", "wkhtmltopdf_filename", ".", "encode", "(", "'utf-8'", ")", ")", "# the bug is that pdfkit.pdfkit.PDFKit.__init__ will attempt to", "# decode the string in its configuration object;", "# https://github.com/JazzCore/python-pdfkit/issues/32", "else", ":", "config", "=", "pdfkit", ".", "configuration", "(", "wkhtmltopdf", "=", "wkhtmltopdf_filename", ")", "# Temporary files that a subprocess can read:", "# http://stackoverflow.com/questions/15169101", "# wkhtmltopdf requires its HTML files to have \".html\" extensions:", "# http://stackoverflow.com/questions/5776125", "h_filename", "=", "None", "f_filename", "=", "None", "try", ":", "if", "header_html", ":", "h_fd", ",", "h_filename", "=", "tempfile", ".", "mkstemp", "(", "suffix", "=", "'.html'", ")", "os", ".", "write", "(", "h_fd", ",", "header_html", ".", "encode", "(", "file_encoding", ")", ")", "os", ".", "close", "(", "h_fd", ")", "wkhtmltopdf_options", "[", "\"header-html\"", "]", "=", "h_filename", "if", "footer_html", ":", "f_fd", ",", "f_filename", "=", "tempfile", ".", "mkstemp", "(", "suffix", "=", "'.html'", ")", "os", ".", "write", "(", "f_fd", ",", "footer_html", ".", "encode", "(", "file_encoding", ")", ")", "os", ".", "close", "(", "f_fd", ")", "wkhtmltopdf_options", "[", "\"footer-html\"", "]", "=", "f_filename", "if", "debug_options", ":", "log", ".", "debug", "(", "\"wkhtmltopdf config: {!r}\"", ",", "config", ")", "log", ".", "debug", "(", "\"wkhtmltopdf_options: {}\"", ",", "pformat", "(", "wkhtmltopdf_options", ")", ")", "kit", "=", "pdfkit", ".", "pdfkit", ".", "PDFKit", "(", "html", ",", "'string'", ",", "configuration", "=", "config", ",", "options", "=", "wkhtmltopdf_options", ")", "if", "on_disk", ":", "path", "=", "output_path", "else", ":", "path", "=", "None", "# With \"path=None\", the to_pdf() function directly returns", "# stdout from a subprocess.Popen().communicate() call (see", "# pdfkit.py). Since universal_newlines is not set, stdout will", "# be bytes in Python 3.", "if", "debug_wkhtmltopdf_args", ":", "log", ".", "debug", "(", "\"Probable current user: {!r}\"", ",", "getpass", ".", "getuser", "(", ")", ")", "log", ".", "debug", "(", "\"wkhtmltopdf arguments will be: {!r}\"", ",", "kit", ".", "command", "(", "path", "=", "path", ")", ")", "return", "kit", ".", "to_pdf", "(", "path", "=", "path", ")", "finally", ":", "if", "h_filename", ":", "os", ".", "remove", "(", "h_filename", ")", "if", "f_filename", ":", "os", ".", "remove", "(", "f_filename", ")", "else", ":", "raise", "AssertionError", "(", "\"Unknown PDF engine\"", ")" ]

[ "Takes", "HTML", "and", "either", "returns", "a", "PDF", "in", "memory", "or", "makes", "one", "on", "disk", "." ]

[ "def", "Fierz_to_EOS_chrom", "(", "C", ",", "dd", ",", "parameters", ")", ":", "p", "=", "parameters", "V", "=", "ckmutil", ".", "ckm", ".", "ckm_tree", "(", "p", "[", "\"Vus\"", "]", ",", "p", "[", "\"Vub\"", "]", ",", "p", "[", "\"Vcb\"", "]", ",", "p", "[", "\"delta\"", "]", ")", "Vtb", "=", "V", "[", "2", ",", "2", "]", "Vts", "=", "V", "[", "2", ",", "1", "]", "e", "=", "sqrt", "(", "4", "*", "pi", "*", "parameters", "[", "'alpha_e'", "]", ")", "gs", "=", "sqrt", "(", "4", "*", "pi", "*", "parameters", "[", "'alpha_s'", "]", ")", "mb", "=", "parameters", "[", "'m_b'", "]", "dic", "=", "{", "\"b->s::c7\"", ":", "16", "*", "pi", "**", "2", "/", "mb", "/", "e", "*", "C", "[", "\"F7gamma\"", "+", "dd", "]", ",", "\"b->s::c7'\"", ":", "16", "*", "pi", "**", "2", "/", "mb", "/", "e", "*", "C", "[", "\"F7pgamma\"", "+", "dd", "]", ",", "\"b->s::c8\"", ":", "16", "*", "pi", "**", "2", "/", "mb", "/", "gs", "*", "C", "[", "\"F8g\"", "+", "dd", "]", ",", "\"b->s::c8'\"", ":", "16", "*", "pi", "**", "2", "/", "mb", "/", "gs", "*", "C", "[", "\"F8pg\"", "+", "dd", "]", "}", "prefactor", "=", "sqrt", "(", "2", ")", "/", "p", "[", "'GF'", "]", "/", "Vtb", "/", "Vts", ".", "conj", "(", ")", "/", "4", "return", "{", "k", ":", "prefactor", "*", "v", "for", "k", ",", "v", "in", "dic", ".", "items", "(", ")", "}" ]

[ "From", "Fierz", "to", "chromomagnetic", "EOS", "basis", "for", "Class", "V", ".", "dd", "should", "be", "of", "the", "form", "sb", "ds", "etc", "." ]

[ "def", "regionsbytag", "(", "self", ",", "*", "tags", ")", ":", "if", "len", "(", "tags", ")", ">", "10", ":", "raise", "ValueError", "(", "'You can specify up to 10 tags'", ")", "if", "not", "tags", ":", "raise", "ValueError", "(", "'No tags specified'", ")", "# We don't check for invalid tags here because the behaviour is", "# fairly intuitive - quering for a non-existent tag returns no", "# regions, excluding it returns all of them.", "@", "api_query", "(", "'regionsbytag'", ",", "tags", "=", "','", ".", "join", "(", "tags", ")", ")", "async", "def", "result", "(", "_", ",", "root", ")", ":", "text", "=", "root", ".", "find", "(", "'REGIONS'", ")", ".", "text", "return", "(", "[", "aionationstates", ".", "Region", "(", "r", ")", "for", "r", "in", "text", ".", "split", "(", "','", ")", "]", "if", "text", "else", "[", "]", ")", "return", "result", "(", "self", ")" ]

[ "All", "regions", "with", "any", "of", "the", "named", "tags", "." ]

[ "def", "distance", "(", "self", ")", "->", "ErrorValue", ":", "if", "'DistCalibrated'", "in", "self", ".", "_data", ":", "dist", "=", "self", ".", "_data", "[", "'DistCalibrated'", "]", "else", ":", "dist", "=", "self", ".", "_data", "[", "\"Dist\"", "]", "if", "'DistCalibratedError'", "in", "self", ".", "_data", ":", "disterr", "=", "self", ".", "_data", "[", "'DistCalibratedError'", "]", "elif", "'DistError'", "in", "self", ".", "_data", ":", "disterr", "=", "self", ".", "_data", "[", "'DistError'", "]", "else", ":", "disterr", "=", "0.0", "return", "ErrorValue", "(", "dist", ",", "disterr", ")" ]

[ "Sample", "-", "to", "-", "detector", "distance" ]

[ "def", "summary", "(", "self", ")", ":", "if", "self", ".", "hasSummary", ":", "return", "BisectingKMeansSummary", "(", "super", "(", "BisectingKMeansModel", ",", "self", ")", ".", "summary", ")", "else", ":", "raise", "RuntimeError", "(", "\"No training summary available for this %s\"", "%", "self", ".", "__class__", ".", "__name__", ")" ]

[ "Gets", "summary", "(", "e", ".", "g", ".", "cluster", "assignments", "cluster", "sizes", ")", "of", "the", "model", "trained", "on", "the", "training", "set", ".", "An", "exception", "is", "thrown", "if", "no", "summary", "exists", "." ]

[ "def", "get_sso", "(", "self", ",", "role", ")", ":", "uri", "=", "\"{}/sso?role={}\"", ".", "format", "(", "self", ".", "data", "[", "'uri'", "]", ",", "role", ")", "return", "self", ".", "_helper", ".", "do_get", "(", "uri", ")" ]

[ "Builds", "the", "SSO", "(", "Single", "Sign", "-", "On", ")", "URL", "parameters", "for", "the", "specified", "enclosure", ".", "This", "allows", "the", "user", "to", "log", "in", "to", "the", "enclosure", "without", "providing", "credentials", ".", "This", "API", "is", "currently", "only", "supported", "by", "C7000", "enclosures", "." ]

[ "def", "to_dict", "(", "self", ")", ":", "return", "{", "\"all_set\"", ":", "self", ".", "_is_all_set", "(", ")", ",", "\"progress\"", ":", "self", ".", "progress", "(", ")", ",", "\"values\"", ":", "{", "property_name", ":", "getattr", "(", "self", ",", "property_name", ")", "or", "[", "]", "for", "property_name", "in", "worker_mapping", "(", ")", ".", "keys", "(", ")", "}", "}" ]

[ "This", "method", "is", "used", "in", "with", "connection", "to", "REST", "API", ".", "It", "basically", "converts", "all", "important", "properties", "to", "dictionary", "which", "may", "be", "used", "by", "frontend", "." ]

[ "def", "get_sanitize_files", "(", "self", ")", ":", "if", "self", ".", "parent", ".", "config", ".", "option", ".", "sanitize_with", "is", "not", "None", ":", "return", "[", "self", ".", "parent", ".", "config", ".", "option", ".", "sanitize_with", "]", "else", ":", "return", "[", "]" ]

[ "Return", "list", "of", "all", "sanitize", "files", "provided", "by", "the", "user", "on", "the", "command", "line", "." ]

[ "def", "_initialize_kvstore", "(", "kvstore", ",", "param_arrays", ",", "arg_params", ",", "param_names", ",", "update_on_kvstore", ")", ":", "for", "idx", ",", "param_on_devs", "in", "enumerate", "(", "param_arrays", ")", ":", "name", "=", "param_names", "[", "idx", "]", "kvstore", ".", "init", "(", "name", ",", "arg_params", "[", "name", "]", ")", "if", "update_on_kvstore", ":", "kvstore", ".", "pull", "(", "name", ",", "param_on_devs", ",", "priority", "=", "-", "idx", ")" ]

[ "Initialize", "kvstore" ]

[ "def", "_parse_place", "(", "place", ",", "is_freeform", "=", "None", ")", ":", "# When freeform already so full address", "if", "is_freeform", "==", "'true'", ":", "location", "=", "place", ".", "get", "(", "'freeformaddress'", ")", "else", ":", "# For parcelle", "if", "place", ".", "get", "(", "'numero'", ")", ":", "location", "=", "place", ".", "get", "(", "'street'", ")", "else", ":", "# When classic geocoding", "# or when reverse geocoding", "location", "=", "\"%s %s\"", "%", "(", "place", ".", "get", "(", "'postal_code'", ",", "''", ")", ",", "place", ".", "get", "(", "'commune'", ",", "''", ")", ",", ")", "if", "place", ".", "get", "(", "'street'", ")", ":", "location", "=", "\"%s, %s\"", "%", "(", "place", ".", "get", "(", "'street'", ",", "''", ")", ",", "location", ",", ")", "if", "place", ".", "get", "(", "'building'", ")", ":", "location", "=", "\"%s %s\"", "%", "(", "place", ".", "get", "(", "'building'", ",", "''", ")", ",", "location", ",", ")", "return", "Location", "(", "location", ",", "(", "place", ".", "get", "(", "'lat'", ")", ",", "place", ".", "get", "(", "'lng'", ")", ")", ",", "place", ")" ]

[ "Get", "the", "location", "lat", "lng", "and", "place", "from", "a", "single", "json", "place", "." ]

[ "def", "calls", "(", "ctx", ",", "obj", ",", "limit", ")", ":", "if", "obj", ".", "upper", "(", ")", "==", "obj", ":", "# Asset", "from", "bitshares", ".", "asset", "import", "Asset", "asset", "=", "Asset", "(", "obj", ",", "full", "=", "True", ")", "calls", "=", "asset", ".", "get_call_orders", "(", "limit", ")", "t", "=", "[", "[", "\"acount\"", ",", "\"debt\"", ",", "\"collateral\"", ",", "\"call price\"", ",", "\"ratio\"", "]", "]", "for", "call", "in", "calls", ":", "t", ".", "append", "(", "[", "str", "(", "call", "[", "\"account\"", "]", "[", "\"name\"", "]", ")", ",", "str", "(", "call", "[", "\"debt\"", "]", ")", ",", "str", "(", "call", "[", "\"collateral\"", "]", ")", ",", "str", "(", "call", "[", "\"call_price\"", "]", ")", ",", "\"%.2f\"", "%", "(", "call", "[", "\"ratio\"", "]", ")", ",", "]", ")", "print_table", "(", "t", ")", "else", ":", "# Account", "from", "bitshares", ".", "dex", "import", "Dex", "dex", "=", "Dex", "(", "bitshares_instance", "=", "ctx", ".", "bitshares", ")", "calls", "=", "dex", ".", "list_debt_positions", "(", "account", "=", "obj", ")", "t", "=", "[", "[", "\"debt\"", ",", "\"collateral\"", ",", "\"call price\"", ",", "\"ratio\"", "]", "]", "for", "symbol", "in", "calls", ":", "t", ".", "append", "(", "[", "str", "(", "calls", "[", "symbol", "]", "[", "\"debt\"", "]", ")", ",", "str", "(", "calls", "[", "symbol", "]", "[", "\"collateral\"", "]", ")", ",", "str", "(", "calls", "[", "symbol", "]", "[", "\"call_price\"", "]", ")", ",", "\"%.2f\"", "%", "(", "calls", "[", "symbol", "]", "[", "\"ratio\"", "]", ")", ",", "]", ")", "print_table", "(", "t", ")" ]

[ "List", "call", "/", "short", "positions", "of", "an", "account", "or", "an", "asset" ]

[ "def", "visit_Dict", "(", "self", ",", "node", ":", "AST", ",", "dfltChaining", ":", "bool", "=", "True", ")", "->", "str", ":", "items", "=", "(", "': '", ".", "join", "(", "(", "self", ".", "visit", "(", "key", ")", ",", "self", ".", "visit", "(", "value", ")", ")", ")", "for", "key", ",", "value", "in", "zip", "(", "node", ".", "keys", ",", "node", ".", "values", ")", ")", "return", "f\"{{{', '.join(items)}}}\"" ]

[ "Return", "dict", "representation", "of", "node", "s", "elements", "." ]

[ "def", "subscribe_to_order_book", "(", "self", ",", "pair", ",", "*", "*", "kwargs", ")", ":", "identifier", "=", "(", "'book'", ",", "pair", ")", "self", ".", "_subscribe", "(", "'book'", ",", "identifier", ",", "symbol", "=", "pair", ",", "*", "*", "kwargs", ")" ]

[ "Subscribe", "to", "the", "passed", "pair", "s", "order", "book", "channel", "." ]

[ "def", "reset_counter", "(", "self", ")", ":", "self", ".", "_cnt_retries", "=", "0", "for", "i", "in", "self", ".", "_url_counter", ":", "self", ".", "_url_counter", "[", "i", "]", "=", "0" ]

[ "reset", "the", "failed", "connection", "counters" ]

[ "def", "eth_getBalance", "(", "self", ",", "address", ",", "block", "=", "BLOCK_TAG_LATEST", ")", ":", "block", "=", "validate_block", "(", "block", ")", "return", "hex_to_dec", "(", "(", "yield", "from", "self", ".", "rpc_call", "(", "'eth_getBalance'", ",", "[", "address", ",", "block", "]", ")", ")", ")" ]

[ "https", ":", "//", "github", ".", "com", "/", "ethereum", "/", "wiki", "/", "wiki", "/", "JSON", "-", "RPC#eth_getbalance" ]

[ "def", "foreground", "(", "color", ")", ":", "if", "color", "not", "in", "foreground_colors", ":", "return", "if", "is_win32", ":", "last_fg", "=", "foreground_colors", "[", "color", "]", "[", "1", "]", "set_color_win32", "(", "last_fg", "|", "last_bg", ")", "else", ":", "set_color_ansi", "(", "foreground_colors", "[", "color", "]", "[", "0", "]", ")" ]

[ "Set", "the", "foreground", "color", "." ]

[ "def", "financials", "(", "symbol", ",", "token", "=", "''", ",", "version", "=", "''", ")", ":", "_raiseIfNotStr", "(", "symbol", ")", "return", "_getJson", "(", "'stock/'", "+", "symbol", "+", "'/financials'", ",", "token", ",", "version", ")" ]

[ "Pulls", "income", "statement", "balance", "sheet", "and", "cash", "flow", "data", "from", "the", "four", "most", "recent", "reported", "quarters", "." ]

[ "def", "is_text", "(", "self", ")", ":", "return", "self", ".", "type", "in", "[", "self", ".", "_TYPE_PASTE", ",", "self", ".", "_TYPE_TEXT", ",", "self", ".", "_TYPE_TWEET", "]" ]

[ "Tells", "if", "this", "message", "is", "a", "text", "message", "." ]

[ "def", "index", "(", "self", ",", "value", ")", ":", "for", "i", ",", "x", "in", "enumerate", "(", "self", ")", ":", "if", "x", "==", "value", ":", "return", "i", "raise", "ValueError", "(", "\"{} is not in list\"", ".", "format", "(", "value", ")", ")" ]

[ "Args", ":", "value", ":", "index" ]

[ "def", "replace_namespaced_network_policy", "(", "self", ",", "name", ",", "namespace", ",", "body", ",", "*", "*", "kwargs", ")", ":", "kwargs", "[", "'_return_http_data_only'", "]", "=", "True", "if", "kwargs", ".", "get", "(", "'async_req'", ")", ":", "return", "self", ".", "replace_namespaced_network_policy_with_http_info", "(", "name", ",", "namespace", ",", "body", ",", "*", "*", "kwargs", ")", "else", ":", "(", "data", ")", "=", "self", ".", "replace_namespaced_network_policy_with_http_info", "(", "name", ",", "namespace", ",", "body", ",", "*", "*", "kwargs", ")", "return", "data" ]

[ "replace", "the", "specified", "NetworkPolicy", "This", "method", "makes", "a", "synchronous", "HTTP", "request", "by", "default", ".", "To", "make", "an", "asynchronous", "HTTP", "request", "please", "pass", "async_req", "=", "True", ">>>", "thread", "=", "api", ".", "replace_namespaced_network_policy", "(", "name", "namespace", "body", "async_req", "=", "True", ")", ">>>", "result", "=", "thread", ".", "get", "()" ]

[ "def", "_advapi32_encrypt", "(", "certificate_or_public_key", ",", "data", ",", "rsa_oaep_padding", "=", "False", ")", ":", "flags", "=", "0", "if", "rsa_oaep_padding", ":", "flags", "=", "Advapi32Const", ".", "CRYPT_OAEP", "out_len", "=", "new", "(", "advapi32", ",", "'DWORD *'", ",", "len", "(", "data", ")", ")", "res", "=", "advapi32", ".", "CryptEncrypt", "(", "certificate_or_public_key", ".", "ex_key_handle", ",", "null", "(", ")", ",", "True", ",", "flags", ",", "null", "(", ")", ",", "out_len", ",", "0", ")", "handle_error", "(", "res", ")", "buffer_len", "=", "deref", "(", "out_len", ")", "buffer", "=", "buffer_from_bytes", "(", "buffer_len", ")", "write_to_buffer", "(", "buffer", ",", "data", ")", "pointer_set", "(", "out_len", ",", "len", "(", "data", ")", ")", "res", "=", "advapi32", ".", "CryptEncrypt", "(", "certificate_or_public_key", ".", "ex_key_handle", ",", "null", "(", ")", ",", "True", ",", "flags", ",", "buffer", ",", "out_len", ",", "buffer_len", ")", "handle_error", "(", "res", ")", "return", "bytes_from_buffer", "(", "buffer", ",", "deref", "(", "out_len", ")", ")", "[", ":", ":", "-", "1", "]" ]

[ "Encrypts", "a", "value", "using", "an", "RSA", "public", "key", "via", "CryptoAPI" ]

[ "def", "resource_update_list", "(", "self", ",", "reset", "=", "False", ")", ":", "if", "not", "self", ".", "_resource_path", ":", "raise", "PluginException", "(", "\"No resource path set\"", ")", "if", "not", "os", ".", "path", ".", "isdir", "(", "self", ".", "_resource_path", ")", ":", "raise", "PluginException", "(", "u\"Resource path directory '{}' not found\"", ".", "format", "(", "self", ".", "_resource_path", ")", ")", "res", "=", "[", "]", "with", "self", ".", "_resource_lock", ":", "if", "reset", ":", "self", ".", "_resources", "=", "{", "}", "old", "=", "dict", "(", "self", ".", "_resources", ")", "for", "dirname", ",", "dirnames", ",", "filenames", "in", "os", ".", "walk", "(", "self", ".", "_resource_path", ")", ":", "for", "file_name", "in", "filenames", ":", "file_ext", "=", "os", ".", "path", ".", "splitext", "(", "file_name", ")", "[", "1", "]", ".", "lower", "(", ")", "[", "1", ":", "]", "if", "file_ext", "not", "in", "self", ".", "_resource_file_types", ":", "self", ".", "debug", "(", "u\"Skipping '{}'\"", ".", "format", "(", "file_name", ")", ")", "continue", "file_path", "=", "os", ".", "path", ".", "join", "(", "dirname", ",", "file_name", ")", "try", ":", "file_hash", "=", "get_file_hash", "(", "file_path", ")", "except", ":", "self", ".", "exception", "(", "u\"Failed to hash '{}'\"", ".", "format", "(", "file_path", ")", ")", "continue", "self", ".", "_resources", "[", "file_name", "]", "=", "{", "'name'", ":", "file_name", ",", "'path'", ":", "file_path", ",", "'hash'", ":", "file_hash", ",", "'checked'", ":", "datetime", ".", "datetime", ".", "utcnow", "(", ")", "}", "# generate diff", "for", "key", "in", "self", ".", "_resources", ":", "resource", "=", "self", ".", "_resources", "[", "key", "]", "if", "key", "not", "in", "old", "or", "old", "[", "key", "]", "[", "'hash'", "]", "!=", "resource", "[", "'hash'", "]", ":", "# new file or hash changed", "res", ".", "append", "(", "(", "key", ",", "resource", "[", "'hash'", "]", ")", ")", "return", "res" ]

[ "Update", "internal", "struct", "of", "resource", "hash", "list", "and", "get", "diff" ]

[ "def", "update_index", "(", "entries", ")", ":", "context", "=", "GLOBAL_TEMPLATE_CONTEXT", ".", "copy", "(", ")", "context", "[", "'entries'", "]", "=", "entries", "context", "[", "'last_build'", "]", "=", "datetime", ".", "datetime", ".", "now", "(", ")", ".", "strftime", "(", "\"%Y-%m-%dT%H:%M:%SZ\"", ")", "list", "(", "map", "(", "lambda", "x", ":", "_render", "(", "context", ",", "x", "[", "0", "]", ",", "os", ".", "path", ".", "join", "(", "CONFIG", "[", "'output_to'", "]", ",", "x", "[", "1", "]", ")", ")", ",", "(", "(", "'entry_index.html'", ",", "'index.html'", ")", ",", "(", "'atom.xml'", ",", "'atom.xml'", ")", ")", ")", ")" ]

[ "find", "the", "last", "10", "entries", "in", "the", "database", "and", "create", "the", "main", "page", ".", "Each", "entry", "in", "has", "an", "doc_id", "so", "we", "only", "get", "the", "last", "10", "doc_ids", "." ]

[ "def", "as_dict", "(", "self", ")", ":", "return", "{", "\"@module\"", ":", "self", ".", "__class__", ".", "__module__", ",", "\"@class\"", ":", "self", ".", "__class__", ".", "__name__", ",", "\"additional_condition\"", ":", "self", ".", "_additional_condition", ",", "\"max_nabundant\"", ":", "self", ".", "max_nabundant", ",", "\"target_environments\"", ":", "self", ".", "target_environments", ",", "\"target_penalty_type\"", ":", "self", ".", "target_penalty_type", ",", "\"max_csm\"", ":", "self", ".", "max_csm", "}" ]

[ "Bson", "-", "serializable", "dict", "representation", "of", "the", "TargettedPenaltiedAbundanceChemenvStrategy", "object", ".", ":", "return", ":", "Bson", "-", "serializable", "dict", "representation", "of", "the", "TargettedPenaltiedAbundanceChemenvStrategy", "object", "." ]

[ "def", "get_time_array", "(", "self", ",", "datetime_simulation_start", "=", "None", ",", "simulation_time_step_seconds", "=", "None", ",", "return_datetime", "=", "False", ",", "time_index_array", "=", "None", ")", ":", "# Original Qout file", "if", "datetime_simulation_start", "is", "not", "None", ":", "self", ".", "datetime_simulation_start", "=", "datetime_simulation_start", "if", "simulation_time_step_seconds", "is", "not", "None", ":", "self", ".", "simulation_time_step_seconds", "=", "simulation_time_step_seconds", "epoch", "=", "datetime", ".", "datetime", "(", "1970", ",", "1", ",", "1", ",", "tzinfo", "=", "utc", ")", "time_units", "=", "\"seconds since {0}\"", ".", "format", "(", "epoch", ")", "# CF-1.6 compliant file", "if", "self", ".", "is_time_variable_valid", "(", ")", ":", "time_array", "=", "self", ".", "qout_nc", ".", "variables", "[", "'time'", "]", "[", ":", "]", "if", "self", ".", "qout_nc", ".", "variables", "[", "'time'", "]", ".", "units", ":", "time_units", "=", "self", ".", "qout_nc", ".", "variables", "[", "'time'", "]", ".", "units", "# Original Qout file", "elif", "self", ".", "_is_legacy_time_valid", "(", ")", ":", "initial_time_seconds", "=", "(", "(", "self", ".", "datetime_simulation_start", ".", "replace", "(", "tzinfo", "=", "utc", ")", "-", "epoch", ")", ".", "total_seconds", "(", ")", "+", "self", ".", "simulation_time_step_seconds", ")", "final_time_seconds", "=", "(", "initial_time_seconds", "+", "self", ".", "size_time", "*", "self", ".", "simulation_time_step_seconds", ")", "time_array", "=", "np", ".", "arange", "(", "initial_time_seconds", ",", "final_time_seconds", ",", "self", ".", "simulation_time_step_seconds", ")", "else", ":", "raise", "ValueError", "(", "\"This file does not contain the time\"", "\" variable. To get time array, add\"", "\" datetime_simulation_start and\"", "\" simulation_time_step_seconds\"", ")", "if", "time_index_array", "is", "not", "None", ":", "time_array", "=", "time_array", "[", "time_index_array", "]", "if", "return_datetime", ":", "time_array", "=", "num2date", "(", "time_array", ",", "time_units", ")", "if", "self", ".", "out_tzinfo", "is", "not", "None", ":", "for", "i", "in", "xrange", "(", "len", "(", "time_array", ")", ")", ":", "# convert time to output timezone", "time_array", "[", "i", "]", "=", "utc", ".", "localize", "(", "time_array", "[", "i", "]", ")", ".", "astimezone", "(", "self", ".", "out_tzinfo", ")", ".", "replace", "(", "tzinfo", "=", "None", ")", "return", "time_array" ]

[ "This", "method", "extracts", "or", "generates", "an", "array", "of", "time", ".", "The", "new", "version", "of", "RAPID", "output", "has", "the", "time", "array", "stored", ".", "However", "the", "old", "version", "requires", "the", "user", "to", "know", "when", "the", "simulation", "began", "and", "the", "time", "step", "of", "the", "output", "." ]

[ "def", "get_kwargs", "(", "self", ",", "args", ")", ":", "# Now we need to figure out which arguments the final function", "# actually needs", "kwargs", "=", "{", "}", "argspec", "=", "inspect", ".", "getargspec", "(", "self", ".", "_func", ")", "required", "=", "set", "(", "argspec", ".", "args", "[", ":", "-", "len", "(", "argspec", ".", "defaults", ")", "]", "if", "argspec", ".", "defaults", "else", "argspec", ".", "args", ")", "for", "arg_name", "in", "argspec", ".", "args", ":", "try", ":", "kwargs", "[", "arg_name", "]", "=", "getattr", "(", "args", ",", "arg_name", ")", "except", "AttributeError", ":", "if", "arg_name", "in", "required", ":", "# If this happens, that's a programming failure", "raise", "# If the function accepts any keyword argument, add whatever", "# remains", "if", "argspec", ".", "keywords", ":", "for", "key", ",", "value", "in", "args", ".", "__dict__", ".", "items", "(", ")", ":", "if", "key", "in", "kwargs", ":", "# Already handled", "continue", "kwargs", "[", "key", "]", "=", "value", "return", "kwargs" ]

[ "Given", "a", "Namespace", "object", "drawn", "from", "argparse", "determines", "the", "keyword", "arguments", "to", "pass", "to", "the", "underlying", "function", ".", "Note", "that", "if", "the", "underlying", "function", "accepts", "all", "keyword", "arguments", "the", "dictionary", "returned", "will", "contain", "the", "entire", "contents", "of", "the", "Namespace", "object", ".", "Also", "note", "that", "an", "AttributeError", "will", "be", "raised", "if", "any", "argument", "required", "by", "the", "function", "is", "not", "set", "in", "the", "Namespace", "object", "." ]

[ "def", "_type_size", "(", "ty", ")", ":", "if", "ty", "[", "0", "]", "in", "(", "'int'", ",", "'uint'", ",", "'bytesM'", ",", "'function'", ")", ":", "return", "32", "elif", "ty", "[", "0", "]", "in", "(", "'tuple'", ")", ":", "result", "=", "0", "for", "ty_i", "in", "ty", "[", "1", "]", ":", "result", "+=", "ABI", ".", "_type_size", "(", "ty_i", ")", "return", "result", "elif", "ty", "[", "0", "]", "in", "(", "'array'", ")", ":", "rep", "=", "ty", "[", "1", "]", "result", "=", "32", "# offset link", "return", "result", "elif", "ty", "[", "0", "]", "in", "(", "'bytes'", ",", "'string'", ")", ":", "result", "=", "32", "# offset link", "return", "result", "raise", "ValueError" ]

[ "Calculate", "static", "type", "size" ]

[ "def", "unpack_infer", "(", "stmt", ",", "context", "=", "None", ")", ":", "if", "isinstance", "(", "stmt", ",", "(", "List", ",", "Tuple", ")", ")", ":", "for", "elt", "in", "stmt", ".", "elts", ":", "if", "elt", "is", "util", ".", "Uninferable", ":", "yield", "elt", "continue", "yield", "from", "unpack_infer", "(", "elt", ",", "context", ")", "return", "dict", "(", "node", "=", "stmt", ",", "context", "=", "context", ")", "# if inferred is a final node, return it and stop", "inferred", "=", "next", "(", "stmt", ".", "infer", "(", "context", ")", ")", "if", "inferred", "is", "stmt", ":", "yield", "inferred", "return", "dict", "(", "node", "=", "stmt", ",", "context", "=", "context", ")", "# else, infer recursively, except Uninferable object that should be returned as is", "for", "inferred", "in", "stmt", ".", "infer", "(", "context", ")", ":", "if", "inferred", "is", "util", ".", "Uninferable", ":", "yield", "inferred", "else", ":", "yield", "from", "unpack_infer", "(", "inferred", ",", "context", ")", "return", "dict", "(", "node", "=", "stmt", ",", "context", "=", "context", ")" ]

[ "recursively", "generate", "nodes", "inferred", "by", "the", "given", "statement", ".", "If", "the", "inferred", "value", "is", "a", "list", "or", "a", "tuple", "recurse", "on", "the", "elements" ]

[ "def", "relation_ids", "(", "reltype", "=", "None", ")", ":", "reltype", "=", "reltype", "or", "relation_type", "(", ")", "relid_cmd_line", "=", "[", "'relation-ids'", ",", "'--format=json'", "]", "if", "reltype", "is", "not", "None", ":", "relid_cmd_line", ".", "append", "(", "reltype", ")", "return", "json", ".", "loads", "(", "subprocess", ".", "check_output", "(", "relid_cmd_line", ")", ".", "decode", "(", "'UTF-8'", ")", ")", "or", "[", "]", "return", "[", "]" ]

[ "A", "list", "of", "relation_ids" ]

[ "def", "to_dot", "(", "self", ",", "name", "=", "'BDD'", ")", ":", "# pragma: no cover", "parts", "=", "[", "'graph'", ",", "name", ",", "'{'", "]", "for", "node", "in", "self", ".", "dfs_postorder", "(", ")", ":", "if", "node", "is", "BDDNODEZERO", ":", "parts", "+=", "[", "'n'", "+", "str", "(", "id", "(", "node", ")", ")", ",", "'[label=0,shape=box];'", "]", "elif", "node", "is", "BDDNODEONE", ":", "parts", "+=", "[", "'n'", "+", "str", "(", "id", "(", "node", ")", ")", ",", "'[label=1,shape=box];'", "]", "else", ":", "v", "=", "_VARS", "[", "node", ".", "root", "]", "parts", ".", "append", "(", "'n'", "+", "str", "(", "id", "(", "node", ")", ")", ")", "parts", ".", "append", "(", "'[label=\"{}\",shape=circle];'", ".", "format", "(", "v", ")", ")", "for", "node", "in", "self", ".", "dfs_postorder", "(", ")", ":", "if", "node", "is", "not", "BDDNODEZERO", "and", "node", "is", "not", "BDDNODEONE", ":", "parts", "+=", "[", "'n'", "+", "str", "(", "id", "(", "node", ")", ")", ",", "'--'", ",", "'n'", "+", "str", "(", "id", "(", "node", ".", "lo", ")", ")", ",", "'[label=0,style=dashed];'", "]", "parts", "+=", "[", "'n'", "+", "str", "(", "id", "(", "node", ")", ")", ",", "'--'", ",", "'n'", "+", "str", "(", "id", "(", "node", ".", "hi", ")", ")", ",", "'[label=1];'", "]", "parts", ".", "append", "(", "'}'", ")", "return", "\" \"", ".", "join", "(", "parts", ")" ]

[ "Convert", "to", "DOT", "language", "representation", "." ]

[ "def", "next_hyperparameter_lowest_mu", "(", "fun_prediction", ",", "fun_prediction_args", ",", "x_bounds", ",", "x_types", ",", "minimize_starting_points", ",", "minimize_constraints_fun", "=", "None", ")", ":", "best_x", "=", "None", "best_acquisition_value", "=", "None", "x_bounds_minmax", "=", "[", "[", "i", "[", "0", "]", ",", "i", "[", "-", "1", "]", "]", "for", "i", "in", "x_bounds", "]", "x_bounds_minmax", "=", "numpy", ".", "array", "(", "x_bounds_minmax", ")", "for", "starting_point", "in", "numpy", ".", "array", "(", "minimize_starting_points", ")", ":", "res", "=", "minimize", "(", "fun", "=", "_lowest_mu", ",", "x0", "=", "starting_point", ".", "reshape", "(", "1", ",", "-", "1", ")", ",", "bounds", "=", "x_bounds_minmax", ",", "method", "=", "\"L-BFGS-B\"", ",", "args", "=", "(", "fun_prediction", ",", "fun_prediction_args", ",", "x_bounds", ",", "x_types", ",", "minimize_constraints_fun", ")", ")", "if", "(", "best_acquisition_value", "is", "None", ")", "or", "(", "res", ".", "fun", "<", "best_acquisition_value", ")", ":", "res", ".", "x", "=", "numpy", ".", "ndarray", ".", "tolist", "(", "res", ".", "x", ")", "res", ".", "x", "=", "lib_data", ".", "match_val_type", "(", "res", ".", "x", ",", "x_bounds", ",", "x_types", ")", "if", "(", "minimize_constraints_fun", "is", "None", ")", "or", "(", "minimize_constraints_fun", "(", "res", ".", "x", ")", "is", "True", ")", ":", "best_acquisition_value", "=", "res", ".", "fun", "best_x", "=", "res", ".", "x", "outputs", "=", "None", "if", "best_x", "is", "not", "None", ":", "mu", ",", "sigma", "=", "fun_prediction", "(", "best_x", ",", "*", "fun_prediction_args", ")", "outputs", "=", "{", "'hyperparameter'", ":", "best_x", ",", "'expected_mu'", ":", "mu", ",", "'expected_sigma'", ":", "sigma", ",", "'acquisition_func'", ":", "\"lm\"", "}", "return", "outputs" ]

[ "Lowest", "Mu", "acquisition", "function" ]

[ "def", "resolve", "(", "var", ",", "context", ")", ":", "try", ":", "return", "var", ".", "resolve", "(", "context", ")", "except", "template", ".", "VariableDoesNotExist", ":", "return", "var", ".", "var" ]

[ "Resolve", "the", "variable", "or", "return", "the", "value", "passed", "to", "it", "in", "the", "first", "place" ]

[ "def", "table", "(", "self", ",", "rows", ",", "col_width", "=", "2", ")", ":", "labels", "=", "[", "str", "(", "x", ")", "for", "x", "in", "range", "(", "1", ",", "len", "(", "rows", ")", "+", "1", ")", "]", "if", "isinstance", "(", "rows", ",", "dict", ")", ":", "labels", "=", "list", "(", "rows", ".", "keys", "(", ")", ")", "rows", "=", "list", "(", "rows", ".", "values", "(", ")", ")", "for", "row", "in", "rows", ":", "label", "=", "labels", ".", "pop", "(", "0", ")", "label", "=", "label", ".", "ljust", "(", "col_width", ")", "message", "=", "\"\\t\"", ".", "join", "(", "row", ")", "self", ".", "custom", "(", "prefix", "=", "label", ",", "message", "=", "message", ")" ]

[ "table", "will", "print", "a", "table", "of", "entries", ".", "If", "the", "rows", "is", "a", "dictionary", "the", "keys", "are", "interpreted", "as", "column", "names", ".", "if", "not", "a", "numbered", "list", "is", "used", "." ]

[ "def", "get_permissions", "(", "self", ",", "role", ")", ":", "target_role", "=", "AuthGroup", ".", "objects", "(", "role", "=", "role", ",", "creator", "=", "self", ".", "client", ")", ".", "first", "(", ")", "if", "not", "target_role", ":", "return", "'[]'", "targets", "=", "AuthPermission", ".", "objects", "(", "groups", "=", "target_role", ",", "creator", "=", "self", ".", "client", ")", ".", "only", "(", "'name'", ")", "return", "json", ".", "loads", "(", "targets", ".", "to_json", "(", ")", ")" ]

[ "gets", "permissions", "of", "role" ]

[ "def", "getAnalyses", "(", "self", ",", "*", "*", "kwargs", ")", ":", "# 'from' is a reserved word, use time_from instead", "if", "kwargs", ".", "get", "(", "'time_from'", ")", ":", "kwargs", "[", "'from'", "]", "=", "kwargs", ".", "get", "(", "'time_from'", ")", "del", "kwargs", "[", "'time_from'", "]", "if", "kwargs", ".", "get", "(", "'time_to'", ")", ":", "kwargs", "[", "'to'", "]", "=", "kwargs", ".", "get", "(", "'time_to'", ")", "del", "kwargs", "[", "'time_to'", "]", "# Warn user about unhandled kwargs", "for", "key", "in", "kwargs", ":", "if", "key", "not", "in", "[", "'limit'", ",", "'offset'", ",", "'from'", ",", "'to'", "]", ":", "sys", ".", "stderr", ".", "write", "(", "'%s not a valid argument for analysis()\\n'", "%", "key", ")", "response", "=", "self", ".", "pingdom", ".", "request", "(", "'GET'", ",", "'analysis/%s'", "%", "self", ".", "id", ",", "kwargs", ")", "return", "[", "PingdomAnalysis", "(", "self", ",", "x", ")", "for", "x", "in", "response", ".", "json", "(", ")", "[", "'analysis'", "]", "]" ]

[ "Returns", "a", "list", "of", "the", "latest", "root", "cause", "analysis", "results", "for", "a", "specified", "check", "." ]

[ "def", "get_response_dict", "(", "self", ",", "helper", ",", "context", ",", "is_formset", ")", ":", "if", "not", "isinstance", "(", "helper", ",", "FormHelper", ")", ":", "raise", "TypeError", "(", "'helper object provided to {% crispy %} tag must be a crispy.helper.FormHelper object.'", ")", "attrs", "=", "helper", ".", "get_attributes", "(", "template_pack", "=", "self", ".", "template_pack", ")", "form_type", "=", "\"form\"", "if", "is_formset", ":", "form_type", "=", "\"formset\"", "# We take form/formset parameters from attrs if they are set, otherwise we use defaults", "response_dict", "=", "{", "'template_pack'", ":", "self", ".", "template_pack", ",", "'%s_action'", "%", "form_type", ":", "attrs", "[", "'attrs'", "]", ".", "get", "(", "\"action\"", ",", "''", ")", ",", "'%s_method'", "%", "form_type", ":", "attrs", ".", "get", "(", "\"form_method\"", ",", "'post'", ")", ",", "'%s_tag'", "%", "form_type", ":", "attrs", ".", "get", "(", "\"form_tag\"", ",", "True", ")", ",", "'%s_class'", "%", "form_type", ":", "attrs", "[", "'attrs'", "]", ".", "get", "(", "\"class\"", ",", "''", ")", ",", "'%s_id'", "%", "form_type", ":", "attrs", "[", "'attrs'", "]", ".", "get", "(", "\"id\"", ",", "\"\"", ")", ",", "'%s_style'", "%", "form_type", ":", "attrs", ".", "get", "(", "\"form_style\"", ",", "None", ")", ",", "'form_error_title'", ":", "attrs", ".", "get", "(", "\"form_error_title\"", ",", "None", ")", ",", "'formset_error_title'", ":", "attrs", ".", "get", "(", "\"formset_error_title\"", ",", "None", ")", ",", "'form_show_errors'", ":", "attrs", ".", "get", "(", "\"form_show_errors\"", ",", "True", ")", ",", "'help_text_inline'", ":", "attrs", ".", "get", "(", "\"help_text_inline\"", ",", "False", ")", ",", "'html5_required'", ":", "attrs", ".", "get", "(", "\"html5_required\"", ",", "False", ")", ",", "'form_show_labels'", ":", "attrs", ".", "get", "(", "\"form_show_labels\"", ",", "True", ")", ",", "'disable_csrf'", ":", "attrs", ".", "get", "(", "\"disable_csrf\"", ",", "False", ")", ",", "'inputs'", ":", "attrs", ".", "get", "(", "'inputs'", ",", "[", "]", ")", ",", "'is_formset'", ":", "is_formset", ",", "'%s_attrs'", "%", "form_type", ":", "attrs", ".", "get", "(", "'attrs'", ",", "''", ")", ",", "'flat_attrs'", ":", "attrs", ".", "get", "(", "'flat_attrs'", ",", "''", ")", ",", "'error_text_inline'", ":", "attrs", ".", "get", "(", "'error_text_inline'", ",", "True", ")", ",", "'label_class'", ":", "attrs", ".", "get", "(", "'label_class'", ",", "''", ")", ",", "'field_class'", ":", "attrs", ".", "get", "(", "'field_class'", ",", "''", ")", ",", "'include_media'", ":", "attrs", ".", "get", "(", "'include_media'", ",", "True", ")", ",", "}", "# Handles custom attributes added to helpers", "for", "attribute_name", ",", "value", "in", "attrs", ".", "items", "(", ")", ":", "if", "attribute_name", "not", "in", "response_dict", ":", "response_dict", "[", "attribute_name", "]", "=", "value", "if", "'csrf_token'", "in", "context", ":", "response_dict", "[", "'csrf_token'", "]", "=", "context", "[", "'csrf_token'", "]", "return", "response_dict" ]

[ "Returns", "a", "dictionary", "with", "all", "the", "parameters", "necessary", "to", "render", "the", "form", "/", "formset", "in", "a", "template", "." ]

[ "def", "get_proteininfo_fields", "(", "poolnames", "=", "False", ",", "genecentric", "=", "False", ")", ":", "allfields", "=", "OrderedDict", "(", ")", "basefields", "=", "[", "peptabledata", ".", "HEADER_PROTEINS", ",", "peptabledata", ".", "HEADER_GENES", ",", "peptabledata", ".", "HEADER_ASSOCIATED", ",", "peptabledata", ".", "HEADER_DESCRIPTIONS", ",", "peptabledata", ".", "HEADER_COVERAGES", ",", "peptabledata", ".", "HEADER_NO_CONTENTPROTEINS", ",", "]", "for", "field", "in", "basefields", ":", "allfields", "[", "field", "]", "=", "False", "allfields", "[", "peptabledata", ".", "HEADER_NO_PSM", "]", "=", "poolnames", "return", "allfields" ]

[ "Returns", "header", "fields", "for", "protein", "(", "group", ")", "information", "." ]

[ "def", "percent_encode_non_ascii_headers", "(", "self", ",", "encoding", "=", "'UTF-8'", ")", ":", "def", "do_encode", "(", "m", ")", ":", "return", "\"*={0}''\"", ".", "format", "(", "encoding", ")", "+", "quote", "(", "to_native_str", "(", "m", ".", "group", "(", "1", ")", ")", ")", "for", "index", "in", "range", "(", "len", "(", "self", ".", "headers", ")", "-", "1", ",", "-", "1", ",", "-", "1", ")", ":", "curr_name", ",", "curr_value", "=", "self", ".", "headers", "[", "index", "]", "try", ":", "# test if header is ascii encodable, no action needed", "curr_value", ".", "encode", "(", "'ascii'", ")", "except", ":", "new_value", "=", "self", ".", "ENCODE_HEADER_RX", ".", "sub", "(", "do_encode", ",", "curr_value", ")", "if", "new_value", "==", "curr_value", ":", "new_value", "=", "quote", "(", "curr_value", ")", "self", ".", "headers", "[", "index", "]", "=", "(", "curr_name", ",", "new_value", ")" ]

[ "Encode", "any", "headers", "that", "are", "not", "plain", "ascii", "as", "UTF", "-", "8", "as", "per", ":", "https", ":", "//", "tools", ".", "ietf", ".", "org", "/", "html", "/", "rfc8187#section", "-", "3", ".", "2", ".", "3", "https", ":", "//", "tools", ".", "ietf", ".", "org", "/", "html", "/", "rfc5987#section", "-", "3", ".", "2", ".", "2" ]

[ "def", "cast", "(", "self", ",", "val", ":", "str", ")", ":", "try", ":", "return", "getattr", "(", "self", ",", "'cast_as_{}'", ".", "format", "(", "self", ".", "cast_as", ".", "__name__", ".", "lower", "(", ")", ")", ")", "(", "val", ")", "except", "AttributeError", ":", "return", "self", ".", "cast_as", "(", "val", ")" ]

[ "converts", "string", "to", "type", "requested", "by", "cast_as" ]

[ "def", "_set_sharing_keys", "(", "self", ",", "keys", ")", ":", "if", "isinstance", "(", "keys", ",", "str", ")", ":", "keys", "=", "{", "keys", "}", "keys", "=", "set", "(", "self", ")", "if", "keys", "is", "None", "else", "set", "(", "keys", ")", "fmto_groups", "=", "self", ".", "_fmto_groups", "keys", ".", "update", "(", "chain", "(", "*", "(", "map", "(", "lambda", "fmto", ":", "fmto", ".", "key", ",", "fmto_groups", "[", "key", "]", ")", "for", "key", "in", "keys", ".", "intersection", "(", "fmto_groups", ")", ")", ")", ")", "keys", ".", "difference_update", "(", "fmto_groups", ")", "return", "keys" ]

[ "Set", "the", "keys", "to", "share", "or", "unshare" ]

[ "def", "from_sas_token", "(", "cls", ",", "address", ",", "sas_token", ",", "eventhub", "=", "None", ",", "*", "*", "kwargs", ")", ":", "address", "=", "_build_uri", "(", "address", ",", "eventhub", ")", "return", "cls", "(", "address", ",", "sas_token", "=", "sas_token", ",", "*", "*", "kwargs", ")" ]

[ "Create", "an", "EventHubClient", "from", "an", "existing", "auth", "token", "or", "token", "generator", "." ]

[ "def", "unzip", "(", "i", ")", ":", "o", "=", "i", ".", "get", "(", "'out'", ",", "''", ")", "duoa", "=", "i", ".", "get", "(", "'data_uoa'", ",", "''", ")", "if", "duoa", "==", "''", ":", "duoa", "=", "'local'", "overwrite", "=", "i", ".", "get", "(", "'overwrite'", ",", "''", ")", "zip", "=", "i", ".", "get", "(", "'zip'", ",", "''", ")", "if", "zip", "==", "''", ":", "zip", "=", "'ckr.zip'", "# Find path to repo", "r", "=", "ck", ".", "find_path_to_repo", "(", "{", "'repo_uoa'", ":", "duoa", "}", ")", "if", "r", "[", "'return'", "]", ">", "0", ":", "return", "r", "path", "=", "r", "[", "'path'", "]", "# Unzipping archive", "rz", "=", "get_and_unzip_archive", "(", "{", "'zip'", ":", "zip", ",", "'path'", ":", "path", ",", "'overwrite'", ":", "overwrite", ",", "'out'", ":", "o", "}", ")", "if", "rz", "[", "'return'", "]", ">", "0", ":", "return", "rz", "return", "{", "'return'", ":", "0", "}" ]

[ "Input", ":", "{", "(", "data_uoa", ")", "-", "repo", "UOA", "where", "to", "unzip", "(", "default", "if", "not", "specified", ")", "zip", "-", "path", "to", "zipfile", "(", "local", "or", "remote", "http", "/", "ftp", ")", "(", "overwrite", ")", "-", "if", "yes", "overwrite", "files", "when", "unarchiving", "}" ]

[ "def", "_teardown", "(", "self", ")", ":", "# __new__ is a super-special case in that even when stubbing a class", "# which implements its own __new__ and subclasses object, the", "# \"Class.__new__\" reference is a staticmethod and not a method (or", "# function). That confuses the \"was_object_method\" logic in", "# StubFunction which then fails to delattr and from then on the class", "# is corrupted. So skip that teardown and use a __new__-specific case.", "setattr", "(", "self", ".", "_instance", ",", "self", ".", "_attr", ",", "staticmethod", "(", "self", ".", "_new", ")", ")", "StubNew", ".", "_cache", ".", "pop", "(", "self", ".", "_type", ")" ]

[ "Overload", "so", "that", "we", "can", "clear", "out", "the", "cache", "after", "a", "test", "run", "." ]

[ "def", "set_model", "(", "self", ",", "model", ")", ":", "self", ".", "_model", "=", "model", "for", "c", "in", "self", ".", "childItems", ":", "c", ".", "set_model", "(", "model", ")" ]

[ "Set", "the", "model", "the", "item", "belongs", "to" ]

[ "def", "send_response", "(", "self", ",", "code", ",", "message", "=", "None", ")", ":", "self", ".", "log_request", "(", "code", ")", "self", ".", "send_response_only", "(", "code", ",", "message", ")", "self", ".", "send_header", "(", "'Server'", ",", "self", ".", "version_string", "(", ")", ")", "self", ".", "send_header", "(", "'Date'", ",", "self", ".", "date_time_string", "(", ")", ")" ]

[ "Add", "the", "response", "header", "to", "the", "headers", "buffer", "and", "log", "the", "response", "code", "." ]

[ "def", "optimal_set_cover", "(", "universe", ",", "subsets", ",", "costs", ")", ":", "pset", "=", "powerset", "(", "subsets", ".", "keys", "(", ")", ")", "best_set", "=", "None", "best_cost", "=", "float", "(", "\"inf\"", ")", "for", "subset", "in", "pset", ":", "covered", "=", "set", "(", ")", "cost", "=", "0", "for", "s", "in", "subset", ":", "covered", ".", "update", "(", "subsets", "[", "s", "]", ")", "cost", "+=", "costs", "[", "s", "]", "if", "len", "(", "covered", ")", "==", "len", "(", "universe", ")", "and", "cost", "<", "best_cost", ":", "best_set", "=", "subset", "best_cost", "=", "cost", "return", "best_set" ]

[ "Optimal", "algorithm", "-", "DONT", "USE", "ON", "BIG", "INPUTS", "-", "O", "(", "2^n", ")", "complexity!", "Finds", "the", "minimum", "cost", "subcollection", "os", "S", "that", "covers", "all", "elements", "of", "U" ]

[ "def", "clone_", "(", "self", ",", "quiet", "=", "False", ")", ":", "ds2", "=", "self", ".", "_duplicate_", "(", "quiet", "=", "True", ")", "if", "ds2", "is", "None", ":", "self", ".", "err", "(", "\"Can not clone instance\"", ")", "else", ":", "if", "quiet", "is", "False", ":", "self", ".", "ok", "(", "\"Instance cloned\"", ")", "return", "ds2" ]

[ "Clone", "the", "DataSwim", "instance" ]

[ "def", "call", "(", "self", ",", "inputs", ")", ":", "image_shape", "=", "tf", ".", "shape", "(", "input", "=", "inputs", ")", "[", "-", "3", ":", "]", "collapsed_shape", "=", "tf", ".", "concat", "(", "(", "[", "-", "1", "]", ",", "image_shape", ")", ",", "axis", "=", "0", ")", "out", "=", "tf", ".", "reshape", "(", "inputs", ",", "collapsed_shape", ")", "# (sample*batch*T, h, w, c)", "out", "=", "self", ".", "conv1", "(", "out", ")", "out", "=", "self", ".", "conv2", "(", "out", ")", "out", "=", "self", ".", "conv3", "(", "out", ")", "out", "=", "self", ".", "conv4", "(", "out", ")", "expanded_shape", "=", "tf", ".", "concat", "(", "(", "tf", ".", "shape", "(", "input", "=", "inputs", ")", "[", ":", "-", "3", "]", ",", "[", "-", "1", "]", ")", ",", "axis", "=", "0", ")", "return", "tf", ".", "reshape", "(", "out", ",", "expanded_shape", ")" ]

[ "Runs", "the", "model", "to", "generate", "an", "intermediate", "representation", "of", "x_t", "." ]

[ "def", "detect_changepoints", "(", "points", ",", "min_time", ",", "data_processor", "=", "acc_difference", ")", ":", "data", "=", "data_processor", "(", "points", ")", "changepoints", "=", "pelt", "(", "normal_mean", "(", "data", ",", "np", ".", "std", "(", "data", ")", ")", ",", "len", "(", "data", ")", ")", "changepoints", ".", "append", "(", "len", "(", "points", ")", "-", "1", ")", "result", "=", "[", "]", "for", "start", ",", "end", "in", "pairwise", "(", "changepoints", ")", ":", "time_diff", "=", "points", "[", "end", "]", ".", "time_difference", "(", "points", "[", "start", "]", ")", "if", "time_diff", ">", "min_time", ":", "result", ".", "append", "(", "start", ")", "# adds the first point", "result", ".", "append", "(", "0", ")", "# adds the last changepoint detected", "result", ".", "append", "(", "len", "(", "points", ")", "-", "1", ")", "return", "sorted", "(", "list", "(", "set", "(", "result", ")", ")", ")" ]

[ "Detects", "changepoints", "on", "points", "that", "have", "at", "least", "a", "specific", "duration" ]

[ "def", "warn_or_error", "(", "removal_version", ",", "deprecated_entity_description", ",", "hint", "=", "None", ",", "deprecation_start_version", "=", "None", ",", "stacklevel", "=", "3", ",", "frame_info", "=", "None", ",", "context", "=", "1", ",", "ensure_stderr", "=", "False", ")", ":", "removal_semver", "=", "validate_deprecation_semver", "(", "removal_version", ",", "'removal version'", ")", "if", "deprecation_start_version", ":", "deprecation_start_semver", "=", "validate_deprecation_semver", "(", "deprecation_start_version", ",", "'deprecation start version'", ")", "if", "deprecation_start_semver", ">=", "removal_semver", ":", "raise", "InvalidSemanticVersionOrderingError", "(", "'The deprecation start version {} must be less than the end version {}.'", ".", "format", "(", "deprecation_start_version", ",", "removal_version", ")", ")", "elif", "PANTS_SEMVER", "<", "deprecation_start_semver", ":", "return", "msg", "=", "'DEPRECATED: {} {} removed in version {}.'", ".", "format", "(", "deprecated_entity_description", ",", "get_deprecated_tense", "(", "removal_version", ")", ",", "removal_version", ")", "if", "hint", ":", "msg", "+=", "'\\n {}'", ".", "format", "(", "hint", ")", "# We need to have filename and line_number for warnings.formatwarning, which appears to be the only", "# way to get a warning message to display to stderr. We get that from frame_info -- it's too bad", "# we have to reconstruct the `stacklevel` logic ourselves, but we do also gain the ability to have", "# multiple lines of context, which is neat.", "if", "frame_info", "is", "None", ":", "frame_info", "=", "_get_frame_info", "(", "stacklevel", ",", "context", "=", "context", ")", "_", ",", "filename", ",", "line_number", ",", "_", ",", "code_context", ",", "_", "=", "frame_info", "if", "code_context", ":", "context_lines", "=", "''", ".", "join", "(", "code_context", ")", "else", ":", "context_lines", "=", "'<no code context available>'", "if", "removal_semver", ">", "PANTS_SEMVER", ":", "if", "ensure_stderr", ":", "# No warning filters can stop us from printing this message directly to stderr.", "warning_msg", "=", "warnings", ".", "formatwarning", "(", "msg", ",", "DeprecationWarning", ",", "filename", ",", "line_number", ",", "line", "=", "context_lines", ")", "print", "(", "warning_msg", ",", "file", "=", "sys", ".", "stderr", ")", "else", ":", "# This output is filtered by warning filters.", "with", "_greater_warnings_context", "(", "context_lines", ")", ":", "warnings", ".", "warn_explicit", "(", "message", "=", "DeprecationWarning", "(", "msg", ")", "if", "PY2", "else", "msg", ",", "category", "=", "DeprecationWarning", ",", "filename", "=", "filename", ",", "lineno", "=", "line_number", ")", "return", "msg", "else", ":", "raise", "CodeRemovedError", "(", "msg", ")" ]

[ "Check", "the", "removal_version", "against", "the", "current", "pants", "version", "." ]

[ "def", "nFreeParams", "(", "self", ")", ":", "nF", "=", "0", "pars", "=", "self", ".", "params", "(", ")", "for", "par", "in", "pars", ":", "if", "par", ".", "isFree", "(", ")", ":", "nF", "+=", "1", "return", "nF" ]

[ "Count", "the", "number", "of", "free", "parameters", "in", "the", "active", "model", "." ]

[ "def", "_get_application_module", "(", "self", ",", "controller", ",", "application", ")", ":", "for", "pkg", "in", "self", ".", "_get_applications", "(", "controller", ")", ":", "if", "pkg", ".", "name", "==", "application", ":", "return", "pkg", ".", "module_name", "return", "application" ]

[ "Return", "the", "module", "for", "an", "application", ".", "If", "it", "s", "a", "entry", "-", "point", "registered", "application", "name", "return", "the", "module", "name", "from", "the", "entry", "points", "data", ".", "If", "not", "the", "passed", "in", "application", "name", "is", "returned", "." ]

[ "def", "get_mmr_constants", "(", ")", ":", "Cnt", "=", "{", "'ISOTOPE'", ":", "'F18'", ",", "'DCYCRR'", ":", "DCYCRR", ",", "'ALPHA'", ":", "ALPHA", ",", "'NRNG'", ":", "NRNG", ",", "'NSRNG'", ":", "NSRNG", ",", "'NCRS'", ":", "NCRS", ",", "'NCRSR'", ":", "NCRSR", ",", "'NBCKT'", ":", "224", ",", "'NSANGLES'", ":", "A", ",", "'NSBINS'", ":", "W", ",", "'Naw'", ":", "-", "1", ",", "# number of total active bins per 2D sino", "'NSN11'", ":", "NSN11", ",", "# number of sinos in span-11", "'NSN1'", ":", "NSN1", ",", "# number of sinos in span-1", "'NSN64'", ":", "NSN64", ",", "# number of sinos in span-1 with no MRD limit", "'MRD'", ":", "MRD", ",", "# maximum ring difference RD", "'SPN'", ":", "SPAN", ",", "# span-1 (1), span-11 (11), ssrb (0)", "'TFOV2'", ":", "TFOV2", ",", "# squared radius of TFOV", "'RNG_STRT'", ":", "RNG_STRT", ",", "# limit axial extension by defining start and end ring", "'RNG_END'", ":", "RNG_END", ",", "# this feature only works with span-1 processing (Cnt['SPN']=1)", "'SS_IMZ'", ":", "SS_IMZ", ",", "#Scatter mu-map iamge size ", "'SS_IMY'", ":", "SS_IMY", ",", "'SS_IMX'", ":", "SS_IMX", ",", "'SS_VXZ'", ":", "SS_VXZ", ",", "'SS_VXY'", ":", "SS_VXY", ",", "'IS_VXZ'", ":", "IS_VXZ", ",", "'SSE_IMZ'", ":", "SSE_IMZ", ",", "#Scatter emission image size", "'SSE_IMY'", ":", "SSE_IMY", ",", "'SSE_IMX'", ":", "SSE_IMX", ",", "'SSE_VXZ'", ":", "SSE_VXZ", ",", "'SSE_VXY'", ":", "SSE_VXY", ",", "'SZ_IMZ'", ":", "SZ_IMZ", ",", "#GPU optimised image size", "'SZ_IMY'", ":", "SZ_IMY", ",", "'SZ_IMX'", ":", "SZ_IMX", ",", "'SZ_VOXZ'", ":", "SZ_VOXZ", ",", "'SZ_VOXY'", ":", "SZ_VOXY", ",", "'SZ_VOXZi'", ":", "SZ_VOXZi", ",", "'SO_IMZ'", ":", "SO_IMZ", ",", "#Original image size (from Siemens)", "'SO_IMY'", ":", "SO_IMY", ",", "'SO_IMX'", ":", "SO_IMX", ",", "'SO_VXZ'", ":", "SO_VXZ", ",", "'SO_VXY'", ":", "SO_VXY", ",", "'SO_VXX'", ":", "SO_VXX", ",", "'NSEG0'", ":", "SEG0", ",", "'RE'", ":", "RE", ",", "#effective ring radius", "'R'", ":", "R", ",", "'SEG'", ":", "seg", ",", "'MNRD'", ":", "minrd", ",", "'MXRD'", ":", "maxrd", ",", "'SCTRNG'", ":", "sct_irng", ",", "'TGAP'", ":", "TGAP", ",", "'OFFGAP'", ":", "OFFGAP", ",", "'AXR'", ":", "AXR", ",", "'R02'", ":", "R02", ",", "#squared electron radius", "'LLD'", ":", "LLD", ",", "#lower energy threashold", "'E511'", ":", "E511", ",", "'ER'", ":", "ER", ",", "#energy resolution", "'COSUPSMX'", ":", "COSUPSMX", ",", "#cosine of max allowed scatter angle", "'NCOS'", ":", "NCOS", ",", "#number of cos samples for LUT", "'COSSTP'", ":", "COSSTP", ",", "#cosine step", "'ICOSSTP'", ":", "ICOSSTP", ",", "#inverse of cosine step", "'ETHRLD'", ":", "ETHRLD", ",", "#intensity emission image threshold (used in scatter modelling)", "'CLGHT'", ":", "CLGHT", ",", "#speed of light [cm/s]", "'CWND'", ":", "CWND", ",", "#coincidence time window [ps]", "'TOFBINN'", ":", "TOFBINN", ",", "#number of TOF bins", "'TOFBINS'", ":", "TOFBINS", ",", "#TOF bin width [ps]", "'TOFBIND'", ":", "TOFBIND", ",", "'ITOFBIND'", ":", "ITOFBIND", ",", "# affine and image size for the reconstructed image, assuming the centre of voxels in mm", "'AFFINE'", ":", "np", ".", "array", "(", "[", "[", "-", "10", "*", "SO_VXX", ",", "0.", ",", "0.", ",", "5.", "*", "SO_IMX", "*", "SO_VXX", "]", ",", "#+5.*SO_VXX", "[", "0.", ",", "10", "*", "SO_VXY", ",", "0.", ",", "-", "5.", "*", "SO_IMY", "*", "SO_VXY", "]", ",", "#+5.*SO_VXY", "[", "0.", ",", "0.", ",", "10", "*", "SO_VXZ", ",", "-", "5.", "*", "SO_IMZ", "*", "SO_VXZ", "]", ",", "#-5.*SO_VXZ", "[", "0.", ",", "0.", ",", "0.", ",", "1.", "]", "]", ")", ",", "'IMSIZE'", ":", "np", ".", "array", "(", "[", "SO_IMZ", ",", "SO_IMY", ",", "SO_IMX", "]", ")", ",", "'BTP'", ":", "0", ",", "#1:non parametric bootstrap, 2: parametric bootstrap (recommended)", "'BTPRT'", ":", "1.0", ",", "# Ratio of bootstrapped/original events (enables downsampling)", "'VERBOSE'", ":", "False", ",", "'SCTSCLEM'", ":", "SCTSCLEM", ",", "'SCTSCLMU'", ":", "SCTSCLMU", ",", "}", "# get the setup for GPU and third party apps", "Cnt", "=", "get_setup", "(", "Cnt", "=", "Cnt", ")", "return", "Cnt" ]

[ "Put", "all", "the", "constants", "together", "in", "a", "dictionary" ]

[ "def", "get_next_parameters", "(", "self", ",", "n", "=", "None", ")", ":", "# Implemented from template for osid.resource.ResourceList.get_next_resources", "if", "n", ">", "self", ".", "available", "(", ")", ":", "# !!! This is not quite as specified (see method docs) !!!", "raise", "IllegalState", "(", "'not enough elements available in this list'", ")", "else", ":", "next_list", "=", "[", "]", "x", "=", "0", "while", "x", "<", "n", ":", "try", ":", "next_list", ".", "append", "(", "self", ".", "next", "(", ")", ")", "except", ":", "# Need to specify exceptions here", "raise", "OperationFailed", "(", ")", "x", "=", "x", "+", "1", "return", "next_list" ]

[ "Gets", "the", "next", "set", "of", "Parameters", "in", "this", "list", "which", "must", "be", "less", "than", "or", "equal", "to", "the", "return", "from", "available", "()", "." ]

[ "def", "create_submission", "(", "wnamespace", ",", "workspace", ",", "cnamespace", ",", "config", ",", "entity", ",", "etype", ",", "expression", "=", "None", ",", "use_callcache", "=", "True", ")", ":", "uri", "=", "\"workspaces/{0}/{1}/submissions\"", ".", "format", "(", "wnamespace", ",", "workspace", ")", "body", "=", "{", "\"methodConfigurationNamespace\"", ":", "cnamespace", ",", "\"methodConfigurationName\"", ":", "config", ",", "\"entityType\"", ":", "etype", ",", "\"entityName\"", ":", "entity", ",", "\"useCallCache\"", ":", "use_callcache", "}", "if", "expression", ":", "body", "[", "'expression'", "]", "=", "expression", "return", "__post", "(", "uri", ",", "json", "=", "body", ")" ]

[ "Submit", "job", "in", "FireCloud", "workspace", "." ]

[ "def", "get_batch_unlock", "(", "end_state", ":", "NettingChannelEndState", ",", ")", "->", "Optional", "[", "MerkleTreeLeaves", "]", ":", "if", "len", "(", "end_state", ".", "merkletree", ".", "layers", "[", "LEAVES", "]", ")", "==", "0", ":", "# pylint: disable=len-as-condition", "return", "None", "lockhashes_to_locks", "=", "dict", "(", ")", "lockhashes_to_locks", ".", "update", "(", "{", "lock", ".", "lockhash", ":", "lock", "for", "secrethash", ",", "lock", "in", "end_state", ".", "secrethashes_to_lockedlocks", ".", "items", "(", ")", "}", ")", "lockhashes_to_locks", ".", "update", "(", "{", "proof", ".", "lock", ".", "lockhash", ":", "proof", ".", "lock", "for", "secrethash", ",", "proof", "in", "end_state", ".", "secrethashes_to_unlockedlocks", ".", "items", "(", ")", "}", ")", "lockhashes_to_locks", ".", "update", "(", "{", "proof", ".", "lock", ".", "lockhash", ":", "proof", ".", "lock", "for", "secrethash", ",", "proof", "in", "end_state", ".", "secrethashes_to_onchain_unlockedlocks", ".", "items", "(", ")", "}", ")", "ordered_locks", "=", "[", "lockhashes_to_locks", "[", "LockHash", "(", "lockhash", ")", "]", "for", "lockhash", "in", "end_state", ".", "merkletree", ".", "layers", "[", "LEAVES", "]", "]", "# Not sure why the cast is needed here. The error was:", "# Incompatible return value type", "# (got \"List[HashTimeLockState]\", expected \"Optional[MerkleTreeLeaves]\")", "return", "cast", "(", "MerkleTreeLeaves", ",", "ordered_locks", ")" ]

[ "Unlock", "proof", "for", "an", "entire", "merkle", "tree", "of", "pending", "locks" ]

[ "def", "iter_zeros", "(", "self", ")", ":", "num", "=", "quotient", "=", "0", "while", "num", "<", "self", ".", "_len", ":", "chunk", "=", "self", ".", "data", "[", "quotient", "]", "if", "chunk", "&", "self", ".", "zero_mask", ":", "remainder", "=", "0", "while", "remainder", "<", "self", ".", "width", "and", "num", "<", "self", ".", "_len", ":", "item", "=", "(", "chunk", ">>", "remainder", ")", "&", "3", "if", "item", "==", "PC_ZERO", ":", "yield", "num", "remainder", "+=", "2", "num", "+=", "1", "else", ":", "num", "+=", "(", "self", ".", "width", ">>", "1", ")", "quotient", "+=", "1" ]

[ "Iterate", "through", "the", "indices", "of", "all", "zero", "items", "." ]

[ "def", "_load_config", "(", "path", ":", "str", ")", "->", "dict", ":", "__", ",", "ext", "=", "os", ".", "path", ".", "splitext", "(", "path", ")", "if", "ext", "in", "[", "'.yaml'", ",", "'.yml'", "]", ":", "import", "ruamel", ".", "yaml", "loader", "=", "ruamel", ".", "yaml", ".", "safe_load", "else", ":", "loader", "=", "json", ".", "load", "with", "open", "(", "path", ")", "as", "f", ":", "config", "=", "loader", "(", "f", ")", "return", "config" ]

[ "Given", "a", "file", "path", "parse", "it", "based", "on", "its", "extension", "(", "YAML", "or", "JSON", ")", "and", "return", "the", "values", "as", "a", "Python", "dictionary", ".", "JSON", "is", "the", "default", "if", "an", "extension", "can", "t", "be", "determined", "." ]

[ "def", "get_instance", "(", "self", ",", "contract_name", ":", "str", ")", "->", "None", ":", "self", ".", "_validate_name_and_references", "(", "contract_name", ")", "# Use a deployment's \"contract_type\" to lookup contract factory", "# in case the deployment uses a contract alias", "contract_type", "=", "self", ".", "deployment_data", "[", "contract_name", "]", "[", "\"contract_type\"", "]", "factory", "=", "self", ".", "contract_factories", "[", "contract_type", "]", "address", "=", "to_canonical_address", "(", "self", ".", "deployment_data", "[", "contract_name", "]", "[", "\"address\"", "]", ")", "contract_kwargs", "=", "{", "\"abi\"", ":", "factory", ".", "abi", ",", "\"bytecode\"", ":", "factory", ".", "bytecode", ",", "\"bytecode_runtime\"", ":", "factory", ".", "bytecode_runtime", ",", "}", "return", "self", ".", "w3", ".", "eth", ".", "contract", "(", "address", "=", "address", ",", "*", "*", "contract_kwargs", ")" ]

[ "Fetches", "a", "contract", "instance", "belonging", "to", "deployment", "after", "validating", "contract", "name", "." ]

[ "def", "psd", "(", "timeseries", ",", "method_func", ",", "*", "args", ",", "*", "*", "kwargs", ")", ":", "# decorator has translated the arguments for us, so just call psdn()", "return", "_psdn", "(", "timeseries", ",", "method_func", ",", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "Generate", "a", "PSD", "using", "a", "method", "function" ]

[ "def", "visit_BoolOp", "(", "self", ",", "node", ")", ":", "# Visit subnodes", "self", ".", "generic_visit", "(", "node", ")", "# Merge all operands types.", "[", "self", ".", "combine", "(", "node", ",", "value", ")", "for", "value", "in", "node", ".", "values", "]" ]

[ "Merge", "BoolOp", "operand", "type", "." ]

[ "def", "_query_pageant", "(", "msg", ")", ":", "hwnd", "=", "_get_pageant_window_object", "(", ")", "if", "not", "hwnd", ":", "# Raise a failure to connect exception, pageant isn't running anymore!", "return", "None", "# create a name for the mmap", "map_name", "=", "\"PageantRequest%08x\"", "%", "thread", ".", "get_ident", "(", ")", "pymap", "=", "_winapi", ".", "MemoryMap", "(", "map_name", ",", "_AGENT_MAX_MSGLEN", ",", "_winapi", ".", "get_security_attributes_for_user", "(", ")", ")", "with", "pymap", ":", "pymap", ".", "write", "(", "msg", ")", "# Create an array buffer containing the mapped filename", "char_buffer", "=", "array", ".", "array", "(", "\"b\"", ",", "b", "(", "map_name", ")", "+", "zero_byte", ")", "# noqa", "char_buffer_address", ",", "char_buffer_size", "=", "char_buffer", ".", "buffer_info", "(", ")", "# Create a string to use for the SendMessage function call", "cds", "=", "COPYDATASTRUCT", "(", "_AGENT_COPYDATA_ID", ",", "char_buffer_size", ",", "char_buffer_address", ")", "response", "=", "ctypes", ".", "windll", ".", "user32", ".", "SendMessageA", "(", "hwnd", ",", "win32con_WM_COPYDATA", ",", "ctypes", ".", "sizeof", "(", "cds", ")", ",", "ctypes", ".", "byref", "(", "cds", ")", ")", "if", "response", ">", "0", ":", "pymap", ".", "seek", "(", "0", ")", "datalen", "=", "pymap", ".", "read", "(", "4", ")", "retlen", "=", "struct", ".", "unpack", "(", "\">I\"", ",", "datalen", ")", "[", "0", "]", "return", "datalen", "+", "pymap", ".", "read", "(", "retlen", ")", "return", "None" ]

[ "Communication", "with", "the", "Pageant", "process", "is", "done", "through", "a", "shared", "memory", "-", "mapped", "file", "." ]

[ "def", "IndexReadPostingLists", "(", "self", ",", "index_urn", ",", "keywords", ",", "start_time", ",", "end_time", ",", "last_seen_map", "=", "None", ")", ":", "keyword_urns", "=", "{", "self", ".", "_KeywordToURN", "(", "index_urn", ",", "k", ")", ":", "k", "for", "k", "in", "keywords", "}", "result", "=", "{", "}", "for", "kw", "in", "keywords", ":", "result", "[", "kw", "]", "=", "set", "(", ")", "for", "keyword_urn", ",", "value", "in", "self", ".", "MultiResolvePrefix", "(", "list", "(", "iterkeys", "(", "keyword_urns", ")", ")", ",", "self", ".", "_INDEX_PREFIX", ",", "timestamp", "=", "(", "start_time", ",", "end_time", "+", "1", ")", ")", ":", "for", "column", ",", "_", ",", "ts", "in", "value", ":", "kw", "=", "keyword_urns", "[", "keyword_urn", "]", "name", "=", "column", "[", "self", ".", "_INDEX_PREFIX_LEN", ":", "]", "result", "[", "kw", "]", ".", "add", "(", "name", ")", "if", "last_seen_map", "is", "not", "None", ":", "last_seen_map", "[", "(", "kw", ",", "name", ")", "]", "=", "max", "(", "last_seen_map", ".", "get", "(", "(", "kw", ",", "name", ")", ",", "-", "1", ")", ",", "ts", ")", "return", "result" ]

[ "Finds", "all", "objects", "associated", "with", "any", "of", "the", "keywords", "." ]

[ "def", "_check_date", "(", "self", ",", "fmt", "=", "'%Y-%m-%d'", ")", ":", "result", "=", "None", "try", ":", "dt_obj", "=", "dt", ".", "datetime", ".", "strptime", "(", "self", ".", "date", ",", "fmt", ")", "except", "ValueError", ":", "result", "=", "'{} does not match YYYY-MM-DD format'", ".", "format", "(", "self", ".", "date", ")", "else", ":", "if", "dt_obj", "<", "self", ".", "_acs_installation_date", ":", "result", "=", "(", "'The observation date cannot occur '", "'before ACS was installed ({})'", ".", "format", "(", "self", ".", "_acs_installation_date", ".", "strftime", "(", "fmt", ")", ")", ")", "elif", "dt_obj", ">", "self", ".", "_extrapolation_date", ":", "result", "=", "(", "'The observation date cannot occur after the '", "'maximum allowable date, {}. Extrapolations of the '", "'instrument throughput after this date lead to '", "'high uncertainties and are therefore invalid.'", ".", "format", "(", "self", ".", "_extrapolation_date", ".", "strftime", "(", "fmt", ")", ")", ")", "finally", ":", "return", "result" ]

[ "Convenience", "method", "for", "determining", "if", "the", "input", "date", "is", "valid", "." ]

[ "def", "shutdown", "(", "self", ")", ":", "logging", ".", "info", "(", "\"Shutting down\"", ")", "self", ".", "closeAllWindows", "(", ")", "self", ".", "notifier", ".", "hide", "(", ")", "self", ".", "service", ".", "shutdown", "(", ")", "self", ".", "monitor", ".", "stop", "(", ")", "self", ".", "quit", "(", ")", "os", ".", "remove", "(", "common", ".", "LOCK_FILE", ")", "# TODO: maybe use atexit to remove the lock/pid file?", "logging", ".", "debug", "(", "\"All shutdown tasks complete... quitting\"", ")" ]

[ "Shut", "down", "the", "entire", "application", "." ]

[ "def", "open", "(", "self", ",", "fn", ")", ":", "return", "open_image", "(", "fn", ",", "convert_mode", "=", "self", ".", "convert_mode", ",", "after_open", "=", "self", ".", "after_open", ")" ]

[ "Open", "image", "in", "fn", "subclass", "and", "overwrite", "for", "custom", "behavior", "." ]

[ "def", "from_stat_file", "(", "cls", ",", "statfile", ",", "timestep", "=", "1", ",", "is_leap_year", "=", "False", ")", ":", "stat", "=", "STAT", "(", "statfile", ")", "# check to be sure the stat file does not have missing tau values", "def", "check_missing", "(", "opt_data", ",", "data_name", ")", ":", "if", "opt_data", "==", "[", "]", ":", "raise", "ValueError", "(", "'Stat file contains no optical data.'", ")", "for", "i", ",", "x", "in", "enumerate", "(", "opt_data", ")", ":", "if", "x", "is", "None", ":", "raise", "ValueError", "(", "'Missing optical depth data for {} at month {}'", ".", "format", "(", "data_name", ",", "i", ")", ")", "check_missing", "(", "stat", ".", "monthly_tau_beam", ",", "'monthly_tau_beam'", ")", "check_missing", "(", "stat", ".", "monthly_tau_diffuse", ",", "'monthly_tau_diffuse'", ")", "return", "cls", ".", "from_ashrae_revised_clear_sky", "(", "stat", ".", "location", ",", "stat", ".", "monthly_tau_beam", ",", "stat", ".", "monthly_tau_diffuse", ",", "timestep", ",", "is_leap_year", ")" ]

[ "Create", "an", "ASHRAE", "Revised", "Clear", "Sky", "wea", "object", "from", "the", "monthly", "sky", "optical", "depths", "in", "a", ".", "stat", "file", "." ]

[ "def", "template_global", "(", "self", ",", "name", ":", "Optional", "[", "str", "]", "=", "None", ")", "->", "Callable", ":", "def", "decorator", "(", "func", ":", "Callable", ")", "->", "Callable", ":", "self", ".", "add_template_global", "(", "func", ",", "name", "=", "name", ")", "return", "func", "return", "decorator" ]

[ "Add", "a", "template", "global", "." ]

[ "def", "best_match", "(", "self", ",", "req", ",", "working_set", ",", "installer", "=", "None", ")", ":", "dist", "=", "working_set", ".", "find", "(", "req", ")", "if", "dist", "is", "not", "None", ":", "return", "dist", "for", "dist", "in", "self", "[", "req", ".", "key", "]", ":", "if", "dist", "in", "req", ":", "return", "dist", "# try to download/install", "return", "self", ".", "obtain", "(", "req", ",", "installer", ")" ]

[ "Find", "distribution", "best", "matching", "req", "and", "usable", "on", "working_set" ]

[ "def", "copy", "(", "self", ")", ":", "x", "=", "self", ".", "to_dict", "(", ")", "x", ".", "pop", "(", "self", ".", "_pkey", ")", "return", "self", ".", "__class__", "(", "*", "*", "x", ")" ]

[ "Creates", "a", "shallow", "copy", "of", "the", "given", "entity", "(", "any", "entities", "that", "can", "be", "retrieved", "from", "a", "OneToMany", "relationship", "will", "not", "be", "copied", ")", "." ]

[ "def", "handle", "(", "self", ",", "t_input", ":", "inference", ".", "TranslatorInput", ",", "t_output", ":", "inference", ".", "TranslatorOutput", ",", "t_walltime", ":", "float", "=", "0.", ")", ":", "line", "=", "\"{sent_id} ||| {target} ||| {score:f} ||| {source} ||| {source_len:d} ||| {target_len:d}\\n\"", "self", ".", "stream", ".", "write", "(", "line", ".", "format", "(", "sent_id", "=", "t_input", ".", "sentence_id", ",", "target", "=", "\" \"", ".", "join", "(", "t_output", ".", "tokens", ")", ",", "score", "=", "t_output", ".", "score", ",", "source", "=", "\" \"", ".", "join", "(", "t_input", ".", "tokens", ")", ",", "source_len", "=", "len", "(", "t_input", ".", "tokens", ")", ",", "target_len", "=", "len", "(", "t_output", ".", "tokens", ")", ")", ")", "attention_matrix", "=", "t_output", ".", "attention_matrix", ".", "T", "for", "i", "in", "range", "(", "0", ",", "attention_matrix", ".", "shape", "[", "0", "]", ")", ":", "attention_vector", "=", "attention_matrix", "[", "i", "]", "self", ".", "stream", ".", "write", "(", "\" \"", ".", "join", "(", "[", "\"%f\"", "%", "value", "for", "value", "in", "attention_vector", "]", ")", ")", "self", ".", "stream", ".", "write", "(", "\"\\n\"", ")", "self", ".", "stream", ".", "write", "(", "\"\\n\"", ")", "self", ".", "stream", ".", "flush", "(", ")" ]

[ ":", "param", "t_input", ":", "Translator", "input", ".", ":", "param", "t_output", ":", "Translator", "output", ".", ":", "param", "t_walltime", ":", "Total", "wall", "-", "clock", "time", "for", "translation", "." ]

[ "def", "hotplugRegisterCallback", "(", "self", ",", "callback", ",", "# pylint: disable=undefined-variable", "events", "=", "HOTPLUG_EVENT_DEVICE_ARRIVED", "|", "HOTPLUG_EVENT_DEVICE_LEFT", ",", "flags", "=", "HOTPLUG_ENUMERATE", ",", "vendor_id", "=", "HOTPLUG_MATCH_ANY", ",", "product_id", "=", "HOTPLUG_MATCH_ANY", ",", "dev_class", "=", "HOTPLUG_MATCH_ANY", ",", "# pylint: enable=undefined-variable", ")", ":", "def", "wrapped_callback", "(", "context_p", ",", "device_p", ",", "event", ",", "_", ")", ":", "assert", "addressof", "(", "context_p", ".", "contents", ")", "==", "addressof", "(", "self", ".", "__context_p", ".", "contents", ")", ",", "(", "context_p", ",", "self", ".", "__context_p", ")", "device", "=", "USBDevice", "(", "self", ",", "device_p", ",", "# pylint: disable=undefined-variable", "event", "!=", "HOTPLUG_EVENT_DEVICE_LEFT", ",", "# pylint: enable=undefined-variable", ")", "self", ".", "__close_set", ".", "add", "(", "device", ")", "unregister", "=", "bool", "(", "callback", "(", "self", ",", "device", ",", "event", ",", ")", ")", "if", "unregister", ":", "del", "self", ".", "__hotplug_callback_dict", "[", "handle", "]", "return", "unregister", "handle", "=", "c_int", "(", ")", "callback_p", "=", "libusb1", ".", "libusb_hotplug_callback_fn_p", "(", "wrapped_callback", ")", "mayRaiseUSBError", "(", "libusb1", ".", "libusb_hotplug_register_callback", "(", "self", ".", "__context_p", ",", "events", ",", "flags", ",", "vendor_id", ",", "product_id", ",", "dev_class", ",", "callback_p", ",", "None", ",", "byref", "(", "handle", ")", ",", ")", ")", "handle", "=", "handle", ".", "value", "# Keep strong references", "assert", "handle", "not", "in", "self", ".", "__hotplug_callback_dict", ",", "(", "handle", ",", "self", ".", "__hotplug_callback_dict", ",", ")", "self", ".", "__hotplug_callback_dict", "[", "handle", "]", "=", "(", "callback_p", ",", "wrapped_callback", ")", "return", "handle" ]

[ "Registers", "an", "hotplug", "callback", ".", "On", "success", "returns", "an", "opaque", "value", "which", "can", "be", "passed", "to", "hotplugDeregisterCallback", ".", "Callback", "must", "accept", "the", "following", "positional", "arguments", ":", "-", "this", "USBContext", "instance", "-", "an", "USBDevice", "instance", "If", "device", "has", "left", "configuration", "descriptors", "may", "not", "be", "available", ".", "Its", "device", "descriptor", "will", "be", "available", ".", "-", "event", "type", "one", "of", ":", "HOTPLUG_EVENT_DEVICE_ARRIVED", "HOTPLUG_EVENT_DEVICE_LEFT", "Callback", "must", "return", "whether", "it", "must", "be", "unregistered", "(", "any", "true", "value", "to", "be", "unregistered", "any", "false", "value", "to", "be", "kept", "registered", ")", "." ]

[ "def", "chunks", "(", "seq", ",", "size", ")", ":", "return", "(", "seq", "[", "pos", ":", "pos", "+", "size", "]", "for", "pos", "in", "range", "(", "0", ",", "len", "(", "seq", ")", ",", "size", ")", ")" ]

[ "simple", "two", "-", "line", "alternative", "to", "ubelt", ".", "chunks" ]

[ "def", "_get_rho", "(", "self", ",", "w", ",", "arr", ")", ":", "lsb", "=", "0", "while", "not", "(", "w", "&", "arr", "[", "lsb", "]", ")", ":", "lsb", "+=", "1", "return", "lsb", "+", "1" ]

[ "Return", "the", "least", "signifiant", "bit", "O", "(", "N", ")", "in", "the", "worst", "case" ]

[ "def", "_call_pip", "(", "*", "args", ")", ":", "all_args", "=", "[", "sys", ".", "executable", ",", "\"-m\"", ",", "\"pip\"", "]", "+", "list", "(", "args", ")", "print", "(", "\"> {}\"", ".", "format", "(", "\" \"", ".", "join", "(", "all_args", ")", ")", ")", "subprocess", ".", "check_call", "(", "all_args", ")" ]

[ "Invoke", "pip", "*", "safely", "*", "and", "in", "the", "*", "supported", "*", "way", ":", "https", ":", "//", "pip", ".", "pypa", ".", "io", "/", "en", "/", "latest", "/", "user_guide", "/", "#using", "-", "pip", "-", "from", "-", "your", "-", "program" ]

[ "def", "get_attribute_data", "(", "attr_ids", ",", "node_ids", ",", "*", "*", "kwargs", ")", ":", "node_attrs", "=", "db", ".", "DBSession", ".", "query", "(", "ResourceAttr", ")", ".", "options", "(", "joinedload_all", "(", "'attr'", ")", ")", ".", "filter", "(", "ResourceAttr", ".", "node_id", ".", "in_", "(", "node_ids", ")", ",", "ResourceAttr", ".", "attr_id", ".", "in_", "(", "attr_ids", ")", ")", ".", "all", "(", ")", "ra_ids", "=", "[", "]", "for", "ra", "in", "node_attrs", ":", "ra_ids", ".", "append", "(", "ra", ".", "id", ")", "resource_scenarios", "=", "db", ".", "DBSession", ".", "query", "(", "ResourceScenario", ")", ".", "filter", "(", "ResourceScenario", ".", "resource_attr_id", ".", "in_", "(", "ra_ids", ")", ")", ".", "options", "(", "joinedload", "(", "'resourceattr'", ")", ")", ".", "options", "(", "joinedload_all", "(", "'dataset.metadata'", ")", ")", ".", "order_by", "(", "ResourceScenario", ".", "scenario_id", ")", ".", "all", "(", ")", "for", "rs", "in", "resource_scenarios", ":", "if", "rs", ".", "dataset", ".", "hidden", "==", "'Y'", ":", "try", ":", "rs", ".", "dataset", ".", "check_read_permission", "(", "kwargs", ".", "get", "(", "'user_id'", ")", ")", "except", ":", "rs", ".", "dataset", ".", "value", "=", "None", "db", ".", "DBSession", ".", "expunge", "(", "rs", ")", "return", "node_attrs", ",", "resource_scenarios" ]

[ "For", "a", "given", "attribute", "or", "set", "of", "attributes", "return", "all", "the", "resources", "and", "resource", "scenarios", "in", "the", "network" ]

[ "def", "_alert_malformed", "(", "self", ",", "msg", ",", "row_num", ")", ":", "if", "self", ".", "error_bad_lines", ":", "raise", "ParserError", "(", "msg", ")", "elif", "self", ".", "warn_bad_lines", ":", "base", "=", "'Skipping line {row_num}: '", ".", "format", "(", "row_num", "=", "row_num", ")", "sys", ".", "stderr", ".", "write", "(", "base", "+", "msg", "+", "'\\n'", ")" ]

[ "Alert", "a", "user", "about", "a", "malformed", "row", "." ]

[ "def", "find", "(", "self", ",", "query", ")", ":", "if", "not", "self", ".", "upstream", ":", "raise", "Exception", "(", "\"CompressionCache must have an upstream\"", ")", "return", "self", ".", "upstream", ".", "find", "(", "query", ")" ]

[ "Passes", "the", "query", "to", "the", "upstream", "if", "it", "exists" ]

[ "def", "prime", "(", "self", ")", ":", "for", "d", "in", "self", ".", "definitions", ".", "values", "(", ")", ":", "self", ".", "defined", "[", "d", ".", "name", "]", "=", "d", ".", "default", "return", "self" ]

[ "Prime", "the", "stored", "values", "based", "on", "default", "values", "found", "in", "property", "definitions", "." ]

[ "def", "set_log_level", "(", "logger", ",", "level", ")", ":", "# type: (logging.Logger, int) -> None", "if", "level", ">", "2", ":", "level", "=", "2", "if", "level", "<", "-", "1", ":", "level", "=", "-", "1", "levels", "=", "{", "-", "1", ":", "logging", ".", "ERROR", ",", "0", ":", "logging", ".", "WARN", ",", "1", ":", "logging", ".", "INFO", ",", "2", ":", "logging", ".", "DEBUG", "}", "logger", ".", "setLevel", "(", "levels", "[", "level", "]", ")" ]

[ "Dynamic", "reconfiguration", "of", "the", "log", "level" ]

[ "def", "write", "(", "self", ",", "oprot", ")", ":", "oprot", ".", "write_struct_begin", "(", "'OnlineDatabaseObjectDetailImage'", ")", "oprot", ".", "write_field_begin", "(", "name", "=", "'full_size_url'", ",", "type", "=", "11", ",", "id", "=", "None", ")", "oprot", ".", "write_string", "(", "self", ".", "full_size_url", ")", "oprot", ".", "write_field_end", "(", ")", "oprot", ".", "write_field_begin", "(", "name", "=", "'mediaid'", ",", "type", "=", "11", ",", "id", "=", "None", ")", "oprot", ".", "write_string", "(", "self", ".", "mediaid", ")", "oprot", ".", "write_field_end", "(", ")", "oprot", ".", "write_field_begin", "(", "name", "=", "'objectid'", ",", "type", "=", "11", ",", "id", "=", "None", ")", "oprot", ".", "write_string", "(", "self", ".", "objectid", ")", "oprot", ".", "write_field_end", "(", ")", "oprot", ".", "write_field_begin", "(", "name", "=", "'src'", ",", "type", "=", "11", ",", "id", "=", "None", ")", "oprot", ".", "write_string", "(", "self", ".", "src", ")", "oprot", ".", "write_field_end", "(", ")", "oprot", ".", "write_field_begin", "(", "name", "=", "'thumbnail_url'", ",", "type", "=", "11", ",", "id", "=", "None", ")", "oprot", ".", "write_string", "(", "self", ".", "thumbnail_url", ")", "oprot", ".", "write_field_end", "(", ")", "oprot", ".", "write_field_begin", "(", "name", "=", "'title'", ",", "type", "=", "11", ",", "id", "=", "None", ")", "oprot", ".", "write_string", "(", "self", ".", "title", ")", "oprot", ".", "write_field_end", "(", ")", "oprot", ".", "write_field_begin", "(", "name", "=", "'type'", ",", "type", "=", "11", ",", "id", "=", "None", ")", "oprot", ".", "write_string", "(", "str", "(", "self", ".", "type", ")", ")", "oprot", ".", "write_field_end", "(", ")", "oprot", ".", "write_field_stop", "(", ")", "oprot", ".", "write_struct_end", "(", ")", "return", "self" ]

[ "Write", "this", "object", "to", "the", "given", "output", "protocol", "and", "return", "self", "." ]

[ "def", "_do_weak_search", "(", "self", ",", "obj", ",", "recursive", ")", ":", "obj", "=", "parse_anything", "(", "obj", ")", "if", "not", "obj", "or", "obj", "not", "in", "self", ":", "raise", "ValueError", "(", "obj", ")", "results", "=", "[", "]", "contexts", "=", "[", "self", "]", "while", "contexts", ":", "context", "=", "contexts", ".", "pop", "(", ")", "i", "=", "len", "(", "context", ".", "nodes", ")", "-", "1", "while", "i", ">=", "0", ":", "node", "=", "context", ".", "get", "(", "i", ")", "if", "obj", ".", "get", "(", "-", "1", ")", "==", "node", ":", "for", "j", "in", "range", "(", "-", "len", "(", "obj", ".", "nodes", ")", ",", "-", "1", ")", ":", "if", "obj", ".", "get", "(", "j", ")", "!=", "context", ".", "get", "(", "i", "+", "j", "+", "1", ")", ":", "break", "else", ":", "i", "-=", "len", "(", "obj", ".", "nodes", ")", "-", "1", "index", "=", "slice", "(", "i", ",", "i", "+", "len", "(", "obj", ".", "nodes", ")", ")", "results", ".", "append", "(", "(", "True", ",", "context", ",", "index", ")", ")", "elif", "recursive", "and", "obj", "in", "node", ":", "contexts", ".", "extend", "(", "node", ".", "__children__", "(", ")", ")", "i", "-=", "1", "if", "not", "results", ":", "if", "not", "recursive", ":", "raise", "ValueError", "(", "obj", ")", "results", ".", "append", "(", "(", "False", ",", "self", ",", "slice", "(", "0", ",", "len", "(", "self", ".", "nodes", ")", ")", ")", ")", "return", "results" ]

[ "Search", "for", "an", "element", "that", "looks", "like", "*", "obj", "*", "within", "the", "node", "list", "." ]

[ "def", "undo", "(", "self", ",", "i", "=", "-", "1", ")", ":", "_history_enabled", "=", "self", ".", "history_enabled", "param", "=", "self", ".", "get_history", "(", "i", ")", "self", ".", "disable_history", "(", ")", "param", ".", "undo", "(", ")", "# TODO: do we really want to remove this? then what's the point of redo?", "self", ".", "remove_parameter", "(", "uniqueid", "=", "param", ".", "uniqueid", ")", "if", "_history_enabled", ":", "self", ".", "enable_history", "(", ")" ]

[ "Undo", "an", "item", "in", "the", "history", "logs" ]

[ "def", "get_volume", "(", "self", ")", ":", "self", ".", "request", "(", "EP_GET_VOLUME", ")", "return", "0", "if", "self", ".", "last_response", "is", "None", "else", "self", ".", "last_response", ".", "get", "(", "'payload'", ")", ".", "get", "(", "'volume'", ")" ]

[ "Get", "the", "current", "volume", "." ]