Datasets:

---

kejian

/

codesearchnet-python-raw

like 1

[ "def", "reward_scope", "(", "self", ",", "state", ":", "Sequence", "[", "tf", ".", "Tensor", "]", ",", "action", ":", "Sequence", "[", "tf", ".", "Tensor", "]", ",", "next_state", ":", "Sequence", "[", "tf", ".", "Tensor", "]", ")", "->", "Dict", "[", "str", ",", "TensorFluent", "]", ":", "scope", "=", "{", "}", "scope", ".", "update", "(", "self", ".", "non_fluents_scope", "(", ")", ")", "scope", ".", "update", "(", "self", ".", "state_scope", "(", "state", ")", ")", "scope", ".", "update", "(", "self", ".", "action_scope", "(", "action", ")", ")", "scope", ".", "update", "(", "self", ".", "next_state_scope", "(", "next_state", ")", ")", "return", "scope" ]

[ "Returns", "the", "complete", "reward", "fluent", "scope", "for", "the", "current", "state", "action", "fluents", "and", "next_state", "fluents", "." ]

[ "def", "_check_for_uploads_from_md5", "(", "self", ")", ":", "# type: (Uploader) -> None", "cv", "=", "self", ".", "_md5_offload", ".", "done_cv", "while", "not", "self", ".", "termination_check_md5", ":", "result", "=", "None", "cv", ".", "acquire", "(", ")", "while", "True", ":", "result", "=", "self", ".", "_md5_offload", ".", "pop_done_queue", "(", ")", "if", "result", "is", "None", ":", "# use cv timeout due to possible non-wake while running", "cv", ".", "wait", "(", "1", ")", "# check for terminating conditions", "if", "self", ".", "termination_check_md5", ":", "break", "else", ":", "break", "cv", ".", "release", "(", ")", "if", "result", "is", "not", "None", ":", "self", ".", "_post_md5_skip_on_check", "(", "result", "[", "0", "]", ",", "result", "[", "3", "]", ")" ]

[ "Check", "queue", "for", "a", "file", "to", "upload", ":", "param", "Uploader", "self", ":", "this" ]

[ "def", "create_from_hdu", "(", "cls", ",", "hdu", ",", "ebins", "=", "None", ")", ":", "convname", "=", "HPX", ".", "identify_HPX_convention", "(", "hdu", ".", "header", ")", "conv", "=", "HPX_FITS_CONVENTIONS", "[", "convname", "]", "try", ":", "pixels", "=", "hdu", ".", "data", "[", "conv", ".", "idxstring", "]", "except", "KeyError", ":", "pixels", "=", "None", "return", "cls", ".", "create_from_header", "(", "hdu", ".", "header", ",", "ebins", ",", "pixels", ")" ]

[ "Creates", "an", "HPX", "object", "from", "a", "FITS", "header", "." ]

[ "def", "nvmlDeviceGetMultiGpuBoard", "(", "handle", ")", ":", "c_multiGpu", "=", "c_uint", "(", ")", "fn", "=", "_nvmlGetFunctionPointer", "(", "\"nvmlDeviceGetMultiGpuBoard\"", ")", "ret", "=", "fn", "(", "handle", ",", "byref", "(", "c_multiGpu", ")", ")", "_nvmlCheckReturn", "(", "ret", ")", "return", "bytes_to_str", "(", "c_multiGpu", ".", "value", ")" ]

[ "r", "/", "**", "*", "Retrieves", "whether", "the", "device", "is", "on", "a", "Multi", "-", "GPU", "Board", "*", "Devices", "that", "are", "on", "multi", "-", "GPU", "boards", "will", "set", "\\", "a", "multiGpuBool", "to", "a", "non", "-", "zero", "value", ".", "*", "*", "For", "Fermi", "&tm", ";", "or", "newer", "fully", "supported", "devices", ".", "*", "*" ]

[ "def", "to_binary", "(", "self", ",", "copy", "=", "False", ")", ":", "if", "self", ".", "vartype", "is", "Vartype", ".", "BINARY", ":", "if", "copy", ":", "return", "self", ".", "copy", "(", ")", "else", ":", "return", "self", "new", "=", "BinaryPolynomial", "(", "{", "}", ",", "Vartype", ".", "BINARY", ")", "# s = 2x - 1", "for", "term", ",", "bias", "in", "self", ".", "items", "(", ")", ":", "for", "t", "in", "map", "(", "frozenset", ",", "powerset", "(", "term", ")", ")", ":", "newbias", "=", "bias", "*", "2", "**", "len", "(", "t", ")", "*", "(", "-", "1", ")", "**", "(", "len", "(", "term", ")", "-", "len", "(", "t", ")", ")", "if", "t", "in", "new", ":", "new", "[", "t", "]", "+=", "newbias", "else", ":", "new", "[", "t", "]", "=", "newbias", "return", "new" ]

[ "Return", "a", "binary", "polynomial", "over", "{", "0", "1", "}", "variables", "." ]

[ "def", "to_sql", "(", "self", ",", "conn", ",", "table_name", ",", "dbapi_module", "=", "None", ",", "use_python_type_specifiers", "=", "False", ",", "use_exact_column_names", "=", "True", ")", ":", "mod_info", "=", "_get_global_dbapi_info", "(", "dbapi_module", ",", "conn", ")", "c", "=", "conn", ".", "cursor", "(", ")", "col_info", "=", "list", "(", "zip", "(", "self", ".", "column_names", "(", ")", ",", "self", ".", "column_types", "(", ")", ")", ")", "if", "not", "use_python_type_specifiers", ":", "_pytype_to_printf", "=", "lambda", "x", ":", "'s'", "# DBAPI2 standard allows for five different ways to specify parameters", "sql_param", "=", "{", "'qmark'", ":", "lambda", "name", ",", "col_num", ",", "col_type", ":", "'?'", ",", "'numeric'", ":", "lambda", "name", ",", "col_num", ",", "col_type", ":", "':'", "+", "str", "(", "col_num", "+", "1", ")", ",", "'named'", ":", "lambda", "name", ",", "col_num", ",", "col_type", ":", "':'", "+", "str", "(", "name", ")", ",", "'format'", ":", "lambda", "name", ",", "col_num", ",", "col_type", ":", "'%'", "+", "_pytype_to_printf", "(", "col_type", ")", ",", "'pyformat'", ":", "lambda", "name", ",", "col_num", ",", "col_type", ":", "'%('", "+", "str", "(", "name", ")", "+", "')'", "+", "_pytype_to_printf", "(", "col_type", ")", ",", "}", "get_sql_param", "=", "sql_param", "[", "mod_info", "[", "'paramstyle'", "]", "]", "# form insert string", "ins_str", "=", "\"INSERT INTO \"", "+", "str", "(", "table_name", ")", "value_str", "=", "\" VALUES (\"", "col_str", "=", "\" (\"", "count", "=", "0", "for", "i", "in", "col_info", ":", "col_str", "+=", "i", "[", "0", "]", "value_str", "+=", "get_sql_param", "(", "i", "[", "0", "]", ",", "count", ",", "i", "[", "1", "]", ")", "if", "count", "<", "len", "(", "col_info", ")", "-", "1", ":", "col_str", "+=", "\",\"", "value_str", "+=", "\",\"", "count", "+=", "1", "col_str", "+=", "\")\"", "value_str", "+=", "\")\"", "if", "use_exact_column_names", ":", "ins_str", "+=", "col_str", "ins_str", "+=", "value_str", "# Some formats require values in an iterable, some a dictionary", "if", "(", "mod_info", "[", "'paramstyle'", "]", "==", "'named'", "or", "mod_info", "[", "'paramstyle'", "]", "==", "'pyformat'", ")", ":", "prepare_sf_row", "=", "lambda", "x", ":", "x", "else", ":", "col_names", "=", "self", ".", "column_names", "(", ")", "prepare_sf_row", "=", "lambda", "x", ":", "[", "x", "[", "i", "]", "for", "i", "in", "col_names", "]", "for", "i", "in", "self", ":", "try", ":", "c", ".", "execute", "(", "ins_str", ",", "prepare_sf_row", "(", "i", ")", ")", "except", "mod_info", "[", "'Error'", "]", "as", "e", ":", "if", "hasattr", "(", "conn", ",", "'rollback'", ")", ":", "conn", ".", "rollback", "(", ")", "raise", "e", "conn", ".", "commit", "(", ")", "c", ".", "close", "(", ")" ]

[ "Convert", "an", "SFrame", "to", "a", "single", "table", "in", "a", "SQL", "database", "." ]

[ "def", "changeSubMenu", "(", "self", ",", "submenu", ")", ":", "if", "submenu", "not", "in", "self", ".", "submenus", ":", "raise", "ValueError", "(", "\"Submenu %s does not exist!\"", "%", "submenu", ")", "elif", "submenu", "==", "self", ".", "activeSubMenu", ":", "return", "# Ignore double submenu activation to prevent bugs in submenu initializer", "old", "=", "self", ".", "activeSubMenu", "self", ".", "activeSubMenu", "=", "submenu", "if", "old", "is", "not", "None", ":", "self", ".", "submenus", "[", "old", "]", ".", "on_exit", "(", "submenu", ")", "self", ".", "submenus", "[", "old", "]", ".", "doAction", "(", "\"exit\"", ")", "self", ".", "submenu", ".", "on_enter", "(", "old", ")", "self", ".", "submenu", ".", "doAction", "(", "\"enter\"", ")" ]

[ "Changes", "the", "submenu", "that", "is", "displayed", ".", ":", "raises", "ValueError", ":", "if", "the", "name", "was", "not", "previously", "registered" ]

[ "def", "perform_request", "(", "self", ",", "method", ",", "url", ",", "headers", "=", "None", ",", "params", "=", "None", ",", "body", "=", "None", ")", ":", "if", "body", "is", "not", "None", ":", "body", "=", "self", ".", "serializer", ".", "dumps", "(", "body", ")", "# some clients or environments don't support sending GET with body", "if", "method", "in", "(", "'HEAD'", ",", "'GET'", ")", "and", "self", ".", "send_get_body_as", "!=", "'GET'", ":", "# send it as post instead", "if", "self", ".", "send_get_body_as", "==", "'POST'", ":", "method", "=", "'POST'", "# or as source parameter", "elif", "self", ".", "send_get_body_as", "==", "'source'", ":", "if", "params", "is", "None", ":", "params", "=", "{", "}", "params", "[", "'source'", "]", "=", "body", "body", "=", "None", "if", "body", "is", "not", "None", ":", "try", ":", "body", "=", "body", ".", "encode", "(", "'utf-8'", ",", "'surrogatepass'", ")", "except", "(", "UnicodeDecodeError", ",", "AttributeError", ")", ":", "# bytes/str - no need to re-encode", "pass", "ignore", "=", "(", ")", "timeout", "=", "None", "if", "params", ":", "timeout", "=", "params", ".", "pop", "(", "'request_timeout'", ",", "None", ")", "ignore", "=", "params", ".", "pop", "(", "'ignore'", ",", "(", ")", ")", "if", "isinstance", "(", "ignore", ",", "int", ")", ":", "ignore", "=", "(", "ignore", ",", ")", "for", "attempt", "in", "range", "(", "self", ".", "max_retries", "+", "1", ")", ":", "connection", "=", "self", ".", "get_connection", "(", ")", "try", ":", "# add a delay before attempting the next retry", "# 0, 1, 3, 7, etc...", "delay", "=", "2", "**", "attempt", "-", "1", "time", ".", "sleep", "(", "delay", ")", "status", ",", "headers_response", ",", "data", "=", "connection", ".", "perform_request", "(", "method", ",", "url", ",", "params", ",", "body", ",", "headers", "=", "headers", ",", "ignore", "=", "ignore", ",", "timeout", "=", "timeout", ")", "except", "TransportError", "as", "e", ":", "if", "method", "==", "'HEAD'", "and", "e", ".", "status_code", "==", "404", ":", "return", "False", "retry", "=", "False", "if", "isinstance", "(", "e", ",", "ConnectionTimeout", ")", ":", "retry", "=", "self", ".", "retry_on_timeout", "elif", "isinstance", "(", "e", ",", "ConnectionError", ")", ":", "retry", "=", "True", "elif", "e", ".", "status_code", "in", "self", ".", "retry_on_status", ":", "retry", "=", "True", "if", "retry", ":", "# only mark as dead if we are retrying", "self", ".", "mark_dead", "(", "connection", ")", "# raise exception on last retry", "if", "attempt", "==", "self", ".", "max_retries", ":", "raise", "else", ":", "raise", "else", ":", "# connection didn't fail, confirm it's live status", "self", ".", "connection_pool", ".", "mark_live", "(", "connection", ")", "if", "method", "==", "'HEAD'", ":", "return", "200", "<=", "status", "<", "300", "if", "data", ":", "data", "=", "self", ".", "deserializer", ".", "loads", "(", "data", ",", "headers_response", ".", "get", "(", "'content-type'", ")", ")", "return", "data" ]

[ "Perform", "the", "actual", "request", ".", "Retrieve", "a", "connection", "from", "the", "connection", "pool", "pass", "all", "the", "information", "to", "it", "s", "perform_request", "method", "and", "return", "the", "data", "." ]

[ "def", "in_unit_of", "(", "self", ",", "unit", ",", "as_quantity", "=", "False", ")", ":", "new_unit", "=", "u", ".", "Unit", "(", "unit", ")", "new_quantity", "=", "self", ".", "as_quantity", ".", "to", "(", "new_unit", ")", "if", "as_quantity", ":", "return", "new_quantity", "else", ":", "return", "new_quantity", ".", "value" ]

[ "Return", "the", "current", "value", "transformed", "to", "the", "new", "units" ]

[ "def", "isfile_strict", "(", "path", ")", ":", "try", ":", "st", "=", "os", ".", "stat", "(", "path", ")", "except", "OSError", ":", "err", "=", "sys", ".", "exc_info", "(", ")", "[", "1", "]", "if", "err", ".", "errno", "in", "(", "errno", ".", "EPERM", ",", "errno", ".", "EACCES", ")", ":", "raise", "return", "False", "else", ":", "return", "stat", ".", "S_ISREG", "(", "st", ".", "st_mode", ")" ]

[ "Same", "as", "os", ".", "path", ".", "isfile", "()", "but", "does", "not", "swallow", "EACCES", "/", "EPERM", "exceptions", "see", ":", "http", ":", "//", "mail", ".", "python", ".", "org", "/", "pipermail", "/", "python", "-", "dev", "/", "2012", "-", "June", "/", "120787", ".", "html" ]

[ "def", "array2nii", "(", "im", ",", "A", ",", "fnii", ",", "descrip", "=", "''", ",", "trnsp", "=", "(", ")", ",", "flip", "=", "(", ")", ",", "storage_as", "=", "[", "]", ")", ":", "if", "not", "len", "(", "trnsp", ")", "in", "[", "0", ",", "3", ",", "4", "]", "and", "not", "len", "(", "flip", ")", "in", "[", "0", ",", "3", "]", ":", "raise", "ValueError", "(", "'e> number of flip and/or transpose elements is incorrect.'", ")", "#---------------------------------------------------------------------------", "#> TRANSLATIONS and FLIPS", "#> get the same geometry as the input NIfTI file in the form of dictionary,", "#>>as obtained from getnii(..., output='all')", "#> permute the axis order in the image array", "if", "isinstance", "(", "storage_as", ",", "dict", ")", "and", "'transpose'", "in", "storage_as", "and", "'flip'", "in", "storage_as", ":", "trnsp", "=", "(", "storage_as", "[", "'transpose'", "]", ".", "index", "(", "0", ")", ",", "storage_as", "[", "'transpose'", "]", ".", "index", "(", "1", ")", ",", "storage_as", "[", "'transpose'", "]", ".", "index", "(", "2", ")", ")", "flip", "=", "storage_as", "[", "'flip'", "]", "if", "trnsp", "==", "(", ")", ":", "im", "=", "im", ".", "transpose", "(", ")", "#> check if the image is 4D (dynamic) and modify as needed", "elif", "len", "(", "trnsp", ")", "==", "3", "and", "im", ".", "ndim", "==", "4", ":", "trnsp", "=", "tuple", "(", "[", "t", "+", "1", "for", "t", "in", "trnsp", "]", "+", "[", "0", "]", ")", "im", "=", "im", ".", "transpose", "(", "trnsp", ")", "else", ":", "im", "=", "im", ".", "transpose", "(", "trnsp", ")", "#> perform flip of x,y,z axes after transposition into proper NIfTI order", "if", "flip", "!=", "(", ")", "and", "len", "(", "flip", ")", "==", "3", ":", "im", "=", "im", "[", ":", ":", "-", "flip", "[", "0", "]", ",", ":", ":", "-", "flip", "[", "1", "]", ",", ":", ":", "-", "flip", "[", "2", "]", ",", "...", "]", "#---------------------------------------------------------------------------", "nii", "=", "nib", ".", "Nifti1Image", "(", "im", ",", "A", ")", "hdr", "=", "nii", ".", "header", "hdr", ".", "set_sform", "(", "None", ",", "code", "=", "'scanner'", ")", "hdr", "[", "'cal_max'", "]", "=", "np", ".", "max", "(", "im", ")", "#np.percentile(im, 90) #", "hdr", "[", "'cal_min'", "]", "=", "np", ".", "min", "(", "im", ")", "hdr", "[", "'descrip'", "]", "=", "descrip", "nib", ".", "save", "(", "nii", ",", "fnii", ")" ]

[ "Store", "the", "numpy", "array", "im", "to", "a", "NIfTI", "file", "fnii", ".", "----", "Arguments", ":", "im", ":", "image", "to", "be", "stored", "in", "NIfTI", "A", ":", "affine", "transformation", "fnii", ":", "output", "NIfTI", "file", "name", ".", "descrip", ":", "the", "description", "given", "to", "the", "file", "trsnp", ":", "transpose", "/", "permute", "the", "dimensions", ".", "In", "NIfTI", "it", "has", "to", "be", "in", "this", "order", ":", "[", "x", "y", "z", "t", "...", "]", ")", "flip", ":", "flip", "tupple", "for", "flipping", "the", "direction", "of", "x", "y", "z", "axes", ".", "(", "1", ":", "no", "flip", "-", "1", ":", "flip", ")", "storage_as", ":", "uses", "the", "flip", "and", "displacement", "as", "given", "by", "the", "following", "NifTI", "dictionary", "obtained", "using", "nimpa", ".", "getnii", "(", "filepath", "output", "=", "all", ")", "." ]

[ "def", "get_attribute_name_id", "(", "attr", ")", ":", "return", "attr", ".", "value", ".", "id", "if", "isinstance", "(", "attr", ".", "value", ",", "ast", ".", "Name", ")", "else", "None" ]

[ "Return", "the", "attribute", "name", "identifier" ]

[ "def", "load_mirteFile", "(", "path", ",", "m", ",", "logger", "=", "None", ")", ":", "l", "=", "logging", ".", "getLogger", "(", "'load_mirteFile'", ")", "if", "logger", "is", "None", "else", "logger", "had", "=", "set", "(", ")", "for", "name", ",", "path", ",", "d", "in", "walk_mirteFiles", "(", "path", ",", "logger", ")", ":", "if", "os", ".", "path", ".", "realpath", "(", "path", ")", "in", "m", ".", "loaded_mirteFiles", ":", "continue", "identifier", "=", "name", "if", "name", "in", "had", ":", "identifier", "=", "path", "else", ":", "had", ".", "add", "(", "name", ")", "l", ".", "info", "(", "'loading %s'", "%", "identifier", ")", "m", ".", "loaded_mirteFiles", ".", "add", "(", "os", ".", "path", ".", "realpath", "(", "path", ")", ")", "_load_mirteFile", "(", "d", ",", "m", ")" ]

[ "Loads", "the", "mirte", "-", "file", "at", "<path", ">", "into", "the", "manager", "<m", ">", "." ]

[ "def", "get_text", "(", "node", ",", "strategy", ")", ":", "textEquivs", "=", "node", ".", "get_TextEquiv", "(", ")", "if", "not", "textEquivs", ":", "log", ".", "debug", "(", "\"No text results on %s %s\"", ",", "node", ",", "node", ".", "id", ")", "return", "''", "# elif strategy == 'index1':", "else", ":", "if", "len", "(", "textEquivs", ")", ">", "1", ":", "index1", "=", "[", "x", "for", "x", "in", "textEquivs", "if", "x", ".", "index", "==", "1", "]", "if", "index1", ":", "return", "index1", "[", "0", "]", ".", "get_Unicode", "(", ")", ".", "strip", "(", ")", "return", "textEquivs", "[", "0", "]", ".", "get_Unicode", "(", ")", ".", "strip", "(", ")" ]

[ "Get", "the", "most", "confident", "text", "results", "either", "those", "with" ]

[ "def", "setup_logger", "(", "log_level", ",", "log_file", "=", "None", ")", ":", "level", "=", "getattr", "(", "logging", ",", "log_level", ".", "upper", "(", ")", ",", "None", ")", "if", "not", "level", ":", "color_print", "(", "\"Invalid log level: %s\"", "%", "log_level", ",", "\"RED\"", ")", "sys", ".", "exit", "(", "1", ")", "# hide traceback when log level is INFO/WARNING/ERROR/CRITICAL", "if", "level", ">=", "logging", ".", "INFO", ":", "sys", ".", "tracebacklimit", "=", "0", "formatter", "=", "ColoredFormatter", "(", "u\"%(log_color)s%(bg_white)s%(levelname)-8s%(reset)s %(message)s\"", ",", "datefmt", "=", "None", ",", "reset", "=", "True", ",", "log_colors", "=", "log_colors_config", ")", "if", "log_file", ":", "handler", "=", "logging", ".", "FileHandler", "(", "log_file", ",", "encoding", "=", "\"utf-8\"", ")", "else", ":", "handler", "=", "logging", ".", "StreamHandler", "(", ")", "handler", ".", "setFormatter", "(", "formatter", ")", "logger", ".", "addHandler", "(", "handler", ")", "logger", ".", "setLevel", "(", "level", ")" ]

[ "setup", "root", "logger", "with", "ColoredFormatter", "." ]

[ "def", "_read_temp", "(", "data", ")", ":", "tout", "=", "StringIO", "(", ")", "tout", ".", "write", "(", "data", ")", "tout", ".", "seek", "(", "0", ")", "output", "=", "tout", ".", "readlines", "(", ")", "tout", ".", "close", "(", ")", "return", "output" ]

[ "Return", "what", "would", "be", "written", "to", "disk" ]

[ "def", "get_supported_binary_ops", "(", ")", ":", "binary_ops", "=", "{", "}", "binary_ops", "[", "np", ".", "add", ".", "__name__", "]", "=", "'+'", "binary_ops", "[", "np", ".", "subtract", ".", "__name__", "]", "=", "'-'", "binary_ops", "[", "np", ".", "multiply", ".", "__name__", "]", "=", "'*'", "binary_ops", "[", "np", ".", "divide", ".", "__name__", "]", "=", "'/'", "return", "binary_ops" ]

[ "Returns", "a", "dictionary", "of", "the", "Weld", "supported", "binary", "ops", "with", "values", "being", "their", "Weld", "symbol", "." ]

[ "def", "folder_cls_from_folder_name", "(", "cls", ",", "folder_name", ",", "locale", ")", ":", "for", "folder_cls", "in", "cls", ".", "WELLKNOWN_FOLDERS", "+", "NON_DELETEABLE_FOLDERS", ":", "if", "folder_name", ".", "lower", "(", ")", "in", "folder_cls", ".", "localized_names", "(", "locale", ")", ":", "return", "folder_cls", "raise", "KeyError", "(", ")" ]

[ "Returns", "the", "folder", "class", "that", "matches", "a", "localized", "folder", "name", "." ]

[ "def", "send_result", "(", "pipe", ",", "data", ")", ":", "try", ":", "pipe", ".", "send", "(", "data", ")", "except", "(", "pickle", ".", "PicklingError", ",", "TypeError", ")", "as", "error", ":", "error", ".", "traceback", "=", "format_exc", "(", ")", "pipe", ".", "send", "(", "RemoteException", "(", "error", ",", "error", ".", "traceback", ")", ")" ]

[ "Send", "result", "handling", "pickling", "and", "communication", "errors", "." ]

[ "def", "objectatrib", "(", "instance", ",", "atrib", ")", ":", "atrib", "=", "atrib", ".", "replace", "(", "\"__\"", ",", "\".\"", ")", "atribs", "=", "[", "]", "atribs", "=", "atrib", ".", "split", "(", "\".\"", ")", "obj", "=", "instance", "for", "atrib", "in", "atribs", ":", "if", "type", "(", "obj", ")", "==", "dict", ":", "result", "=", "obj", "[", "atrib", "]", "else", ":", "try", ":", "result", "=", "getattr", "(", "obj", ",", "atrib", ")", "(", ")", "except", "Exception", ":", "result", "=", "getattr", "(", "obj", ",", "atrib", ")", "obj", "=", "result", "return", "result" ]

[ "this", "filter", "is", "going", "to", "be", "useful", "to", "execute", "an", "object", "method", "or", "get", "an", "object", "attribute", "dynamically", ".", "this", "method", "is", "going", "to", "take", "into", "account", "the", "atrib", "param", "can", "contains", "underscores" ]

[ "def", "validate", "(", "self", ",", "value", ",", "model", "=", "None", ",", "context", "=", "None", ")", ":", "regex", "=", "self", ".", "regex", "(", ")", "match", "=", "regex", ".", "match", "(", "value", ")", "if", "not", "match", ":", "return", "Error", "(", "self", ".", "not_email", ")", "# success otherwise", "return", "Error", "(", ")" ]

[ "Validate", "Perform", "value", "validation", "and", "return", "result" ]

[ "def", "distinct_counts", "(", "self", ")", ":", "# hash the haplotypes", "k", "=", "[", "hash", "(", "self", ".", "values", "[", ":", ",", "i", "]", ".", "tobytes", "(", ")", ")", "for", "i", "in", "range", "(", "self", ".", "shape", "[", "1", "]", ")", "]", "# count and sort", "# noinspection PyArgumentList", "counts", "=", "sorted", "(", "collections", ".", "Counter", "(", "k", ")", ".", "values", "(", ")", ",", "reverse", "=", "True", ")", "return", "np", ".", "asarray", "(", "counts", ")" ]

[ "Return", "counts", "for", "each", "distinct", "haplotype", "." ]

[ "def", "zpk", "(", "self", ",", "zeros", ",", "poles", ",", "gain", ",", "analog", "=", "True", ",", "*", "*", "kwargs", ")", ":", "return", "self", ".", "filter", "(", "zeros", ",", "poles", ",", "gain", ",", "analog", "=", "analog", ",", "*", "*", "kwargs", ")" ]

[ "Filter", "this", "TimeSeries", "by", "applying", "a", "zero", "-", "pole", "-", "gain", "filter" ]

[ "def", "setDoc", "(", "self", ",", "doc", ")", ":", "self", ".", "ui", ".", "overAtten", ".", "setNum", "(", "doc", "[", "'overloaded_attenuation'", "]", ")", "# also set composite stim type", "# self.ui.traceType.setText(doc['testtype'])", "self", ".", "ui", ".", "componentDetails", ".", "clearDoc", "(", ")", "self", ".", "ui", ".", "componentDetails", ".", "setDoc", "(", "doc", "[", "'components'", "]", ")" ]

[ "Presents", "the", "documentation" ]

[ "def", "_fill_sample_count", "(", "self", ",", "node", ")", ":", "node", "[", "'sampleCount'", "]", "+=", "sum", "(", "self", ".", "_fill_sample_count", "(", "child", ")", "for", "child", "in", "node", "[", "'children'", "]", ")", "return", "node", "[", "'sampleCount'", "]" ]

[ "Counts", "and", "fills", "sample", "counts", "inside", "call", "tree", "." ]

[ "def", "loads", "(", "s", ",", "strip_comments", "=", "False", ",", "*", "*", "kw", ")", ":", "kw", "[", "'strip_comments'", "]", "=", "strip_comments", "return", "[", "parse_node", "(", "ss", ".", "strip", "(", ")", ",", "*", "*", "kw", ")", "for", "ss", "in", "s", ".", "split", "(", "';'", ")", "if", "ss", ".", "strip", "(", ")", "]" ]

[ "Load", "a", "list", "of", "trees", "from", "a", "Newick", "formatted", "string", "." ]

[ "def", "process_resource", "(", "self", ",", "req", ",", "resp", ",", "resource", ",", "uri_kwargs", "=", "None", ")", ":", "if", "'user'", "in", "req", ".", "context", ":", "return", "identifier", "=", "self", ".", "identify", "(", "req", ",", "resp", ",", "resource", ",", "uri_kwargs", ")", "user", "=", "self", ".", "try_storage", "(", "identifier", ",", "req", ",", "resp", ",", "resource", ",", "uri_kwargs", ")", "if", "user", "is", "not", "None", ":", "req", ".", "context", "[", "'user'", "]", "=", "user", "# if did not succeed then we need to add this to list of available", "# challenges.", "elif", "self", ".", "challenge", "is", "not", "None", ":", "req", ".", "context", ".", "setdefault", "(", "'challenges'", ",", "list", "(", ")", ")", ".", "append", "(", "self", ".", "challenge", ")" ]

[ "Process", "resource", "after", "routing", "to", "it", "." ]

[ "def", "start_stack", "(", "self", ",", "stack", ")", ":", "url", "=", "'{0}/v3/stacks/{1}/start'", ".", "format", "(", "self", ".", "host", ",", "stack", ")", "return", "self", ".", "__post", "(", "url", ")" ]

[ "启动服务组" ]

[ "def", "remove", "(", "image", ")", ":", "path", "=", "os", ".", "path", ".", "join", "(", "IMG_DIR", ",", "image", ")", "if", "os", ".", "path", ".", "isfile", "(", "path", ")", ":", "os", ".", "remove", "(", "path", ")" ]

[ "Remove", "an", "image", "to", "the", "GUI", "img", "library", "." ]

[ "def", "on_deleted", "(", "self", ",", "event", ")", ":", "if", "not", "self", ".", "_event_error", ":", "self", ".", "logger", ".", "info", "(", "u\"Change detected from deletion of: %s\"", ",", "event", ".", "src_path", ")", "# Never try to compile the deleted source", "self", ".", "compile_dependencies", "(", "event", ".", "src_path", ",", "include_self", "=", "False", ")" ]

[ "Called", "when", "a", "file", "or", "directory", "is", "deleted", "." ]

[ "def", "register", "(", "app", ",", "uri", ",", "file_or_directory", ",", "pattern", ",", "use_modified_since", ",", "use_content_range", ")", ":", "# TODO: Though mach9 is not a file server, I feel like we should at least", "# make a good effort here. Modified-since is nice, but we could", "# also look into etags, expires, and caching", "# If we're not trying to match a file directly,", "# serve from the folder", "if", "not", "path", ".", "isfile", "(", "file_or_directory", ")", ":", "uri", "+=", "'<file_uri:'", "+", "pattern", "+", "'>'", "async", "def", "_handler", "(", "request", ",", "file_uri", "=", "None", ")", ":", "# Using this to determine if the URL is trying to break out of the path", "# served. os.path.realpath seems to be very slow", "if", "file_uri", "and", "'../'", "in", "file_uri", ":", "raise", "InvalidUsage", "(", "\"Invalid URL\"", ")", "# Merge served directory and requested file if provided", "# Strip all / that in the beginning of the URL to help prevent python", "# from herping a derp and treating the uri as an absolute path", "root_path", "=", "file_path", "=", "file_or_directory", "if", "file_uri", ":", "file_path", "=", "path", ".", "join", "(", "file_or_directory", ",", "sub", "(", "'^[/]*'", ",", "''", ",", "file_uri", ")", ")", "# URL decode the path sent by the browser otherwise we won't be able to", "# match filenames which got encoded (filenames with spaces etc)", "file_path", "=", "path", ".", "abspath", "(", "unquote", "(", "file_path", ")", ")", "if", "not", "file_path", ".", "startswith", "(", "path", ".", "abspath", "(", "unquote", "(", "root_path", ")", ")", ")", ":", "raise", "FileNotFound", "(", "'File not found'", ",", "path", "=", "file_or_directory", ",", "relative_url", "=", "file_uri", ")", "try", ":", "headers", "=", "{", "}", "# Check if the client has been sent this file before", "# and it has not been modified since", "stats", "=", "None", "if", "use_modified_since", ":", "stats", "=", "await", "stat", "(", "file_path", ")", "modified_since", "=", "strftime", "(", "'%a, %d %b %Y %H:%M:%S GMT'", ",", "gmtime", "(", "stats", ".", "st_mtime", ")", ")", "if", "request", ".", "headers", ".", "get", "(", "'If-Modified-Since'", ")", "==", "modified_since", ":", "return", "HTTPResponse", "(", "status", "=", "304", ")", "headers", "[", "'Last-Modified'", "]", "=", "modified_since", "_range", "=", "None", "if", "use_content_range", ":", "_range", "=", "None", "if", "not", "stats", ":", "stats", "=", "await", "stat", "(", "file_path", ")", "headers", "[", "'Accept-Ranges'", "]", "=", "'bytes'", "headers", "[", "'Content-Length'", "]", "=", "str", "(", "stats", ".", "st_size", ")", "if", "request", ".", "method", "!=", "'HEAD'", ":", "try", ":", "_range", "=", "ContentRangeHandler", "(", "request", ",", "stats", ")", "except", "HeaderNotFound", ":", "pass", "else", ":", "del", "headers", "[", "'Content-Length'", "]", "for", "key", ",", "value", "in", "_range", ".", "headers", ".", "items", "(", ")", ":", "headers", "[", "key", "]", "=", "value", "if", "request", ".", "method", "==", "'HEAD'", ":", "return", "HTTPResponse", "(", "headers", "=", "headers", ",", "content_type", "=", "guess_type", "(", "file_path", ")", "[", "0", "]", "or", "'text/plain'", ")", "else", ":", "return", "await", "file", "(", "file_path", ",", "headers", "=", "headers", ",", "_range", "=", "_range", ")", "except", "ContentRangeError", ":", "raise", "except", "Exception", ":", "raise", "FileNotFound", "(", "'File not found'", ",", "path", "=", "file_or_directory", ",", "relative_url", "=", "file_uri", ")", "app", ".", "route", "(", "uri", ",", "methods", "=", "[", "'GET'", ",", "'HEAD'", "]", ")", "(", "_handler", ")" ]

[ "Register", "a", "static", "directory", "handler", "with", "Mach9", "by", "adding", "a", "route", "to", "the", "router", "and", "registering", "a", "handler", "." ]

[ "def", "visit", "(", "(", "prefix", ",", "strip", ",", "found", ")", ",", "dirname", ",", "names", ")", ":", "files", "=", "[", "]", "# Iterate over a copy of names, modify names", "for", "name", "in", "names", "[", ":", "]", ":", "path", "=", "os", ".", "path", ".", "join", "(", "dirname", ",", "name", ")", "# Ignore directories - we will visit later", "if", "os", ".", "path", ".", "isdir", "(", "path", ")", ":", "# Remove directories we don't want to visit later", "if", "isbad", "(", "name", ")", ":", "names", ".", "remove", "(", "name", ")", "continue", "elif", "isgood", "(", "name", ")", ":", "files", ".", "append", "(", "path", ")", "destination", "=", "os", ".", "path", ".", "join", "(", "prefix", ",", "dirname", "[", "strip", ":", "]", ")", "found", ".", "append", "(", "(", "destination", ",", "files", ")", ")" ]

[ "Visit", "directory", "create", "distutil", "tuple", "Add", "distutil", "tuple", "for", "each", "directory", "using", "this", "format", ":", "(", "destination", "[", "dirname", "/", "file1", "dirname", "/", "file2", "...", "]", ")", "distutil", "will", "copy", "later", "file1", "file2", "...", "info", "destination", "." ]

[ "def", "_readsie", "(", "self", ",", "pos", ")", ":", "codenum", ",", "pos", "=", "self", ".", "_readuie", "(", "pos", ")", "if", "not", "codenum", ":", "return", "0", ",", "pos", "try", ":", "if", "self", "[", "pos", "]", ":", "return", "-", "codenum", ",", "pos", "+", "1", "else", ":", "return", "codenum", ",", "pos", "+", "1", "except", "IndexError", ":", "raise", "ReadError", "(", "\"Read off end of bitstring trying to read code.\"", ")" ]

[ "Return", "interpretation", "of", "next", "bits", "as", "a", "signed", "interleaved", "exponential", "-", "Golomb", "code", "." ]

[ "def", "rst2html", "(", "rst_src", ",", "*", "*", "kwargs", ")", ":", "pub", "=", "rst2pub", "(", "rst_src", ",", "settings_overrides", "=", "kwargs", ",", "writer_name", "=", "'html'", ")", "return", "pub", ".", "writer", ".", "parts", "[", "'body'", "]" ]

[ "Convert", "a", "reStructuredText", "string", "into", "a", "unicode", "HTML", "fragment", "." ]

[ "def", "evaluate_box_proposals", "(", "predictions", ",", "dataset", ",", "thresholds", "=", "None", ",", "area", "=", "\"all\"", ",", "limit", "=", "None", ")", ":", "# Record max overlap value for each gt box", "# Return vector of overlap values", "areas", "=", "{", "\"all\"", ":", "0", ",", "\"small\"", ":", "1", ",", "\"medium\"", ":", "2", ",", "\"large\"", ":", "3", ",", "\"96-128\"", ":", "4", ",", "\"128-256\"", ":", "5", ",", "\"256-512\"", ":", "6", ",", "\"512-inf\"", ":", "7", ",", "}", "area_ranges", "=", "[", "[", "0", "**", "2", ",", "1e5", "**", "2", "]", ",", "# all", "[", "0", "**", "2", ",", "32", "**", "2", "]", ",", "# small", "[", "32", "**", "2", ",", "96", "**", "2", "]", ",", "# medium", "[", "96", "**", "2", ",", "1e5", "**", "2", "]", ",", "# large", "[", "96", "**", "2", ",", "128", "**", "2", "]", ",", "# 96-128", "[", "128", "**", "2", ",", "256", "**", "2", "]", ",", "# 128-256", "[", "256", "**", "2", ",", "512", "**", "2", "]", ",", "# 256-512", "[", "512", "**", "2", ",", "1e5", "**", "2", "]", ",", "]", "# 512-inf", "assert", "area", "in", "areas", ",", "\"Unknown area range: {}\"", ".", "format", "(", "area", ")", "area_range", "=", "area_ranges", "[", "areas", "[", "area", "]", "]", "gt_overlaps", "=", "[", "]", "num_pos", "=", "0", "for", "image_id", ",", "prediction", "in", "enumerate", "(", "predictions", ")", ":", "original_id", "=", "dataset", ".", "id_to_img_map", "[", "image_id", "]", "img_info", "=", "dataset", ".", "get_img_info", "(", "image_id", ")", "image_width", "=", "img_info", "[", "\"width\"", "]", "image_height", "=", "img_info", "[", "\"height\"", "]", "prediction", "=", "prediction", ".", "resize", "(", "(", "image_width", ",", "image_height", ")", ")", "# sort predictions in descending order", "# TODO maybe remove this and make it explicit in the documentation", "inds", "=", "prediction", ".", "get_field", "(", "\"objectness\"", ")", ".", "sort", "(", "descending", "=", "True", ")", "[", "1", "]", "prediction", "=", "prediction", "[", "inds", "]", "ann_ids", "=", "dataset", ".", "coco", ".", "getAnnIds", "(", "imgIds", "=", "original_id", ")", "anno", "=", "dataset", ".", "coco", ".", "loadAnns", "(", "ann_ids", ")", "gt_boxes", "=", "[", "obj", "[", "\"bbox\"", "]", "for", "obj", "in", "anno", "if", "obj", "[", "\"iscrowd\"", "]", "==", "0", "]", "gt_boxes", "=", "torch", ".", "as_tensor", "(", "gt_boxes", ")", ".", "reshape", "(", "-", "1", ",", "4", ")", "# guard against no boxes", "gt_boxes", "=", "BoxList", "(", "gt_boxes", ",", "(", "image_width", ",", "image_height", ")", ",", "mode", "=", "\"xywh\"", ")", ".", "convert", "(", "\"xyxy\"", ")", "gt_areas", "=", "torch", ".", "as_tensor", "(", "[", "obj", "[", "\"area\"", "]", "for", "obj", "in", "anno", "if", "obj", "[", "\"iscrowd\"", "]", "==", "0", "]", ")", "if", "len", "(", "gt_boxes", ")", "==", "0", ":", "continue", "valid_gt_inds", "=", "(", "gt_areas", ">=", "area_range", "[", "0", "]", ")", "&", "(", "gt_areas", "<=", "area_range", "[", "1", "]", ")", "gt_boxes", "=", "gt_boxes", "[", "valid_gt_inds", "]", "num_pos", "+=", "len", "(", "gt_boxes", ")", "if", "len", "(", "gt_boxes", ")", "==", "0", ":", "continue", "if", "len", "(", "prediction", ")", "==", "0", ":", "continue", "if", "limit", "is", "not", "None", "and", "len", "(", "prediction", ")", ">", "limit", ":", "prediction", "=", "prediction", "[", ":", "limit", "]", "overlaps", "=", "boxlist_iou", "(", "prediction", ",", "gt_boxes", ")", "_gt_overlaps", "=", "torch", ".", "zeros", "(", "len", "(", "gt_boxes", ")", ")", "for", "j", "in", "range", "(", "min", "(", "len", "(", "prediction", ")", ",", "len", "(", "gt_boxes", ")", ")", ")", ":", "# find which proposal box maximally covers each gt box", "# and get the iou amount of coverage for each gt box", "max_overlaps", ",", "argmax_overlaps", "=", "overlaps", ".", "max", "(", "dim", "=", "0", ")", "# find which gt box is 'best' covered (i.e. 'best' = most iou)", "gt_ovr", ",", "gt_ind", "=", "max_overlaps", ".", "max", "(", "dim", "=", "0", ")", "assert", "gt_ovr", ">=", "0", "# find the proposal box that covers the best covered gt box", "box_ind", "=", "argmax_overlaps", "[", "gt_ind", "]", "# record the iou coverage of this gt box", "_gt_overlaps", "[", "j", "]", "=", "overlaps", "[", "box_ind", ",", "gt_ind", "]", "assert", "_gt_overlaps", "[", "j", "]", "==", "gt_ovr", "# mark the proposal box and the gt box as used", "overlaps", "[", "box_ind", ",", ":", "]", "=", "-", "1", "overlaps", "[", ":", ",", "gt_ind", "]", "=", "-", "1", "# append recorded iou coverage level", "gt_overlaps", ".", "append", "(", "_gt_overlaps", ")", "gt_overlaps", "=", "torch", ".", "cat", "(", "gt_overlaps", ",", "dim", "=", "0", ")", "gt_overlaps", ",", "_", "=", "torch", ".", "sort", "(", "gt_overlaps", ")", "if", "thresholds", "is", "None", ":", "step", "=", "0.05", "thresholds", "=", "torch", ".", "arange", "(", "0.5", ",", "0.95", "+", "1e-5", ",", "step", ",", "dtype", "=", "torch", ".", "float32", ")", "recalls", "=", "torch", ".", "zeros_like", "(", "thresholds", ")", "# compute recall for each iou threshold", "for", "i", ",", "t", "in", "enumerate", "(", "thresholds", ")", ":", "recalls", "[", "i", "]", "=", "(", "gt_overlaps", ">=", "t", ")", ".", "float", "(", ")", ".", "sum", "(", ")", "/", "float", "(", "num_pos", ")", "# ar = 2 * np.trapz(recalls, thresholds)", "ar", "=", "recalls", ".", "mean", "(", ")", "return", "{", "\"ar\"", ":", "ar", ",", "\"recalls\"", ":", "recalls", ",", "\"thresholds\"", ":", "thresholds", ",", "\"gt_overlaps\"", ":", "gt_overlaps", ",", "\"num_pos\"", ":", "num_pos", ",", "}" ]

[ "Evaluate", "detection", "proposal", "recall", "metrics", ".", "This", "function", "is", "a", "much", "faster", "alternative", "to", "the", "official", "COCO", "API", "recall", "evaluation", "code", ".", "However", "it", "produces", "slightly", "different", "results", "." ]

[ "def", "download_unzip", "(", "names", "=", "None", ",", "normalize_filenames", "=", "False", ",", "verbose", "=", "True", ")", ":", "names", "=", "[", "names", "]", "if", "isinstance", "(", "names", ",", "(", "str", ",", "basestring", ")", ")", "else", "names", "# names = names or list(BIG_URLS.keys()) # download them all, if none specified!", "file_paths", "=", "{", "}", "for", "name", "in", "names", ":", "created", "=", "create_big_url", "(", "name", ")", "name", "=", "(", "created", "or", "name", ")", ".", "lower", "(", ")", ".", "strip", "(", ")", "if", "name", "in", "BIG_URLS", ":", "filepath", "=", "download_name", "(", "name", ",", "verbose", "=", "verbose", ")", "if", "not", "filepath", ":", "continue", "file_paths", "[", "name", "]", "=", "normalize_ext_rename", "(", "filepath", ")", "logger", ".", "debug", "(", "'downloaded name={} to filepath={}'", ".", "format", "(", "name", ",", "file_paths", "[", "name", "]", ")", ")", "fplower", "=", "file_paths", "[", "name", "]", ".", "lower", "(", ")", "if", "fplower", ".", "endswith", "(", "'.tar.gz'", ")", ":", "logger", ".", "info", "(", "'Extracting {}'", ".", "format", "(", "file_paths", "[", "name", "]", ")", ")", "file_paths", "[", "name", "]", "=", "untar", "(", "file_paths", "[", "name", "]", ",", "verbose", "=", "verbose", ")", "logger", ".", "debug", "(", "'download_untar.filepaths='", "+", "str", "(", "file_paths", ")", ")", "elif", "file_paths", "[", "name", "]", ".", "lower", "(", ")", ".", "endswith", "(", "'.zip'", ")", ":", "file_paths", "[", "name", "]", "=", "unzip", "(", "file_paths", "[", "name", "]", ",", "verbose", "=", "verbose", ")", "logger", ".", "debug", "(", "'download_unzip.filepaths='", "+", "str", "(", "file_paths", ")", ")", "else", ":", "df", "=", "pd", ".", "read_html", "(", "DATA_INFO", "[", "'url'", "]", "[", "name", "]", ",", "*", "*", "DATA_INFO", "[", "'downloader_kwargs'", "]", "[", "name", "]", ")", "[", "-", "1", "]", "df", ".", "columns", "=", "clean_columns", "(", "df", ".", "columns", ")", "file_paths", "[", "name", "]", "=", "os", ".", "path", ".", "join", "(", "DATA_PATH", ",", "name", "+", "'.csv'", ")", "df", ".", "to_csv", "(", "file_paths", "[", "name", "]", ")", "file_paths", "[", "name", "]", "=", "normalize_ext_rename", "(", "file_paths", "[", "name", "]", ")", "return", "file_paths" ]

[ "r", "Download", "CSV", "or", "HTML", "tables", "listed", "in", "names", "unzip", "and", "to", "DATA_PATH", "/", "names", ".", "csv", ".", "txt", "etc" ]

[ "def", "get_verified_jwt", "(", "providers", ",", "audiences", ",", "check_authorization_header", "=", "True", ",", "check_query_arg", "=", "True", ",", "request", "=", "None", ",", "cache", "=", "memcache", ")", ":", "if", "not", "(", "check_authorization_header", "or", "check_query_arg", ")", ":", "raise", "ValueError", "(", "'Either check_authorization_header or check_query_arg must be True.'", ")", "if", "check_query_arg", "and", "request", "is", "None", ":", "raise", "ValueError", "(", "'Cannot check query arg without request object.'", ")", "schemes", "=", "(", "'Bearer'", ",", ")", "if", "check_authorization_header", "else", "(", ")", "keys", "=", "(", "'access_token'", ",", ")", "if", "check_query_arg", "else", "(", ")", "token", "=", "_get_token", "(", "request", "=", "request", ",", "allowed_auth_schemes", "=", "schemes", ",", "allowed_query_keys", "=", "keys", ")", "if", "token", "is", "None", ":", "return", "None", "time_now", "=", "long", "(", "time", ".", "time", "(", ")", ")", "for", "provider", "in", "providers", ":", "parsed_token", "=", "_parse_and_verify_jwt", "(", "token", ",", "time_now", ",", "(", "provider", "[", "'issuer'", "]", ",", ")", ",", "audiences", ",", "provider", "[", "'cert_uri'", "]", ",", "cache", ")", "if", "parsed_token", "is", "not", "None", ":", "return", "parsed_token", "return", "None" ]

[ "This", "function", "will", "extract", "verify", "and", "parse", "a", "JWT", "token", "from", "the", "Authorization", "header", "or", "access_token", "query", "argument", "." ]

[ "def", "chimera_node_placer_2d", "(", "m", ",", "n", ",", "t", ",", "scale", "=", "1.", ",", "center", "=", "None", ",", "dim", "=", "2", ")", ":", "import", "numpy", "as", "np", "tile_center", "=", "t", "//", "2", "tile_length", "=", "t", "+", "3", "# 1 for middle of cross, 2 for spacing between tiles", "# want the enter plot to fill in [0, 1] when scale=1", "scale", "/=", "max", "(", "m", ",", "n", ")", "*", "tile_length", "-", "3", "grid_offsets", "=", "{", "}", "if", "center", "is", "None", ":", "center", "=", "np", ".", "zeros", "(", "dim", ")", "else", ":", "center", "=", "np", ".", "asarray", "(", "center", ")", "paddims", "=", "dim", "-", "2", "if", "paddims", "<", "0", ":", "raise", "ValueError", "(", "\"layout must have at least two dimensions\"", ")", "if", "len", "(", "center", ")", "!=", "dim", ":", "raise", "ValueError", "(", "\"length of center coordinates must match dimension of layout\"", ")", "def", "_xy_coords", "(", "i", ",", "j", ",", "u", ",", "k", ")", ":", "# row, col, shore, shore index", "# first get the coordinatiates within the tile", "if", "k", "<", "tile_center", ":", "p", "=", "k", "else", ":", "p", "=", "k", "+", "1", "if", "u", ":", "xy", "=", "np", ".", "array", "(", "[", "tile_center", ",", "-", "1", "*", "p", "]", ")", "else", ":", "xy", "=", "np", ".", "array", "(", "[", "p", ",", "-", "1", "*", "tile_center", "]", ")", "# next offset the corrdinates based on the which tile", "if", "i", ">", "0", "or", "j", ">", "0", ":", "if", "(", "i", ",", "j", ")", "in", "grid_offsets", ":", "xy", "+=", "grid_offsets", "[", "(", "i", ",", "j", ")", "]", "else", ":", "off", "=", "np", ".", "array", "(", "[", "j", "*", "tile_length", ",", "-", "1", "*", "i", "*", "tile_length", "]", ")", "xy", "+=", "off", "grid_offsets", "[", "(", "i", ",", "j", ")", "]", "=", "off", "# convention for Chimera-lattice pictures is to invert the y-axis", "return", "np", ".", "hstack", "(", "(", "xy", "*", "scale", ",", "np", ".", "zeros", "(", "paddims", ")", ")", ")", "+", "center", "return", "_xy_coords" ]

[ "Generates", "a", "function", "that", "converts", "Chimera", "indices", "to", "x", "y", "coordinates", "for", "a", "plot", "." ]

[ "def", "get_json_files", "(", "files", ",", "recursive", "=", "False", ")", ":", "json_files", "=", "[", "]", "if", "not", "files", ":", "return", "json_files", "for", "fn", "in", "files", ":", "if", "os", ".", "path", ".", "isdir", "(", "fn", ")", ":", "children", "=", "list_json_files", "(", "fn", ",", "recursive", ")", "json_files", ".", "extend", "(", "children", ")", "elif", "is_json", "(", "fn", ")", ":", "json_files", ".", "append", "(", "fn", ")", "else", ":", "continue", "if", "not", "json_files", ":", "raise", "NoJSONFileFoundError", "(", "\"No JSON files found!\"", ")", "return", "json_files" ]

[ "Return", "a", "list", "of", "files", "to", "validate", "from", "files", ".", "If", "a", "member", "of", "files", "is", "a", "directory", "its", "children", "with", "a", ".", "json", "extension", "will", "be", "added", "to", "the", "return", "value", "." ]

[ "def", "make", "(", "self", ")", ":", "log", ".", "setLevel", "(", "self", ".", "log_level", ")", "created", "=", "[", "]", "self", ".", "set_class_dict", "(", ")", "start", "=", "datetime", ".", "datetime", ".", "now", "(", ")", "log", ".", "info", "(", "\" # of classes to create: %s\"", "%", "len", "(", "self", ".", "class_dict", ")", ")", "log", ".", "debug", "(", "\" creating classes that are not subclassed\"", ")", "for", "name", ",", "cls_defs", "in", "self", ".", "class_dict", ".", "items", "(", ")", ":", "# if name in ['bf_Organization', 'bf_Agent']:", "# pdb.set_trace()", "if", "not", "self", ".", "class_dict", "[", "name", "]", ".", "get", "(", "'rdfs_subClassOf'", ")", ":", "created", ".", "append", "(", "name", ")", "setattr", "(", "MODULE", ".", "rdfclass", ",", "name", ",", "types", ".", "new_class", "(", "name", ",", "(", "RdfClassBase", ",", ")", ",", "{", "#'metaclass': RdfClassMeta,", "'cls_defs'", ":", "cls_defs", "}", ")", ")", "log", ".", "debug", "(", "\" created %s classes in: %s\"", ",", "len", "(", "created", ")", ",", "(", "datetime", ".", "datetime", ".", "now", "(", ")", "-", "start", ")", ")", "for", "name", "in", "created", ":", "del", "self", ".", "class_dict", "[", "name", "]", "left", "=", "len", "(", "self", ".", "class_dict", ")", "classes", "=", "[", "]", "while", "left", ">", "0", ":", "new", "=", "[", "]", "for", "name", ",", "cls_defs", "in", "self", ".", "class_dict", ".", "items", "(", ")", ":", "# if name in ['bf_Organization', 'bf_Agent']:", "# pdb.set_trace()", "parents", "=", "self", ".", "class_dict", "[", "name", "]", ".", "get", "(", "'rdfs_subClassOf'", ")", "if", "not", "parents", ":", "bases", "+=", "(", "RdfClassBase", ",", ")", "else", ":", "for", "parent", "in", "make_list", "(", "parents", ")", ":", "bases", "=", "tuple", "(", ")", "if", "parent", "in", "created", "or", "parent", "in", "classes", ":", "if", "parent", "in", "classes", ":", "bases", "+=", "(", "RdfClassBase", ",", ")", "else", ":", "base", "=", "getattr", "(", "MODULE", ".", "rdfclass", ",", "parent", ")", "bases", "+=", "(", "base", ",", ")", "+", "base", ".", "__bases__", "if", "len", "(", "bases", ")", ">", "0", ":", "created", ".", "append", "(", "name", ")", "setattr", "(", "MODULE", ".", "rdfclass", ",", "name", ",", "types", ".", "new_class", "(", "name", ",", "bases", ",", "{", "#'metaclass': RdfClassMeta,", "'cls_defs'", ":", "cls_defs", "}", ")", ")", "for", "name", "in", "created", ":", "try", ":", "del", "self", ".", "class_dict", "[", "name", "]", "except", "KeyError", ":", "pass", "if", "left", "==", "len", "(", "self", ".", "class_dict", ")", ":", "# c_list = [self.class_dict[name].get('rdfs_subClassOf') \\", "# for name in self.class_dict]", "missing_parents", "=", "[", "]", "for", "name", "in", "self", ".", "class_dict", ":", "missing_parents", "+=", "self", ".", "class_dict", "[", "name", "]", ".", "get", "(", "'rdfs_subClassOf'", ",", "[", "]", ")", "missing_parents", "=", "set", "(", "missing_parents", ")", "still_valid", "=", "set", "(", "[", "name", "for", "name", "in", "self", ".", "class_dict", "if", "name", "not", "in", "missing_parents", "]", ")", "classes", "=", "list", "(", "missing_parents", ".", "difference", "(", "set", "(", "self", ".", "class_dict", ".", "keys", "(", ")", ")", ")", ")", "# classess = []", "# for cl in c_list:", "# for item in cl:", "# classes.append(item)", "for", "name", "in", "self", ".", "class_dict", ":", "if", "name", "in", "classes", ":", "classes", ".", "remove", "(", "name", ")", "for", "p_name", "in", "self", ".", "class_dict", "[", "name", "]", ".", "get", "(", "'rdfs_subClassOf'", ",", "[", "]", ")", ".", "copy", "(", ")", ":", "if", "p_name", "in", "classes", ":", "self", ".", "class_dict", "[", "name", "]", "[", "'rdfs_subClassOf'", "]", ".", "remove", "(", "p_name", ")", "# pdb.set_trace()", "left", "=", "len", "(", "self", ".", "class_dict", ")", "# self.tie_properties(created)", "log", ".", "info", "(", "\" created all classes in %s\"", ",", "(", "datetime", ".", "datetime", ".", "now", "(", ")", "-", "start", ")", ")" ]

[ "reads", "through", "the", "definitions", "and", "generates", "an", "python", "class", "for", "each", "definition" ]

[ "def", "get_output_ref", "(", "self", ",", "field", ",", "index", "=", "None", ",", "metadata", "=", "None", ")", ":", "link", "=", "{", "\"$dnanexus_link\"", ":", "{", "\"analysis\"", ":", "self", ".", "_dxid", ",", "\"field\"", ":", "field", "}", "}", "if", "index", "is", "not", "None", ":", "link", "[", "\"$dnanexus_link\"", "]", "[", "\"index\"", "]", "=", "index", "if", "metadata", "is", "not", "None", ":", "link", "[", "\"$dnanexus_link\"", "]", "[", "\"metadata\"", "]", "=", "metadata", "return", "link" ]

[ ":", "param", "field", ":", "Output", "field", "name", "of", "this", "analysis", ":", "type", "field", ":", "string", ":", "param", "index", ":", "If", "the", "referenced", "field", "is", "an", "array", "optionally", "specify", "an", "index", "(", "starting", "from", "0", ")", "to", "indicate", "a", "particular", "member", "of", "the", "array", ":", "type", "index", ":", "int", ":", "param", "metadata", ":", "If", "the", "referenced", "field", "is", "of", "a", "data", "object", "class", "a", "string", "indicating", "the", "metadata", "that", "should", "be", "read", "e", ".", "g", ".", "name", "properties", ".", "propkey", "details", ".", "refgenome", ":", "type", "metadata", ":", "string" ]

[ "def", "_read_para_echo_response_signed", "(", "self", ",", "code", ",", "cbit", ",", "clen", ",", "*", ",", "desc", ",", "length", ",", "version", ")", ":", "_data", "=", "self", ".", "_read_fileng", "(", "clen", ")", "echo_response_signed", "=", "dict", "(", "type", "=", "desc", ",", "critical", "=", "cbit", ",", "length", "=", "clen", ",", "data", "=", "_data", ",", ")", "_plen", "=", "length", "-", "clen", "if", "_plen", ":", "self", ".", "_read_fileng", "(", "_plen", ")", "return", "echo_response_signed" ]

[ "Read", "HIP", "ECHO_RESPONSE_SIGNED", "parameter", "." ]

[ "def", "ssh_to_task", "(", "task", ")", "->", "paramiko", ".", "SSHClient", ":", "username", "=", "task", ".", "ssh_username", "hostname", "=", "task", ".", "public_ip", "ssh_key_fn", "=", "get_keypair_fn", "(", ")", "print", "(", "f\"ssh -i {ssh_key_fn} {username}@{hostname}\"", ")", "pkey", "=", "paramiko", ".", "RSAKey", ".", "from_private_key_file", "(", "ssh_key_fn", ")", "ssh_client", "=", "paramiko", ".", "SSHClient", "(", ")", "ssh_client", ".", "set_missing_host_key_policy", "(", "paramiko", ".", "AutoAddPolicy", "(", ")", ")", "assert", "ssh_client", "counter", "=", "1", "while", "True", ":", "try", ":", "ssh_client", ".", "connect", "(", "hostname", "=", "hostname", ",", "username", "=", "username", ",", "pkey", "=", "pkey", ")", "if", "counter", "%", "11", "==", "0", ":", "# occasionally re-obtain public ip, machine could've gotten restarted", "hostname", "=", "task", ".", "public_ip", "break", "except", "Exception", "as", "e", ":", "print", "(", "f'{task.name}: Exception connecting to {hostname} via ssh (could be a timeout): {e}'", ")", "time", ".", "sleep", "(", "RETRY_INTERVAL_SEC", ")", "return", "ssh_client" ]

[ "Create", "ssh", "connection", "to", "task", "s", "machine" ]

[ "def", "add_widget", "(", "self", ",", "wid", ",", "index", "=", "0", ",", "canvas", "=", "None", ")", ":", "super", "(", ")", ".", "add_widget", "(", "wid", ",", "index", ",", "canvas", ")", "if", "not", "hasattr", "(", "wid", ",", "'group'", ")", ":", "return", "wid", ".", "_no_use_canvas", "=", "True", "mycanvas", "=", "(", "self", ".", "canvas", ".", "before", "if", "canvas", "==", "'before'", "else", "self", ".", "canvas", ".", "after", "if", "canvas", "==", "'after'", "else", "self", ".", "canvas", ")", "mycanvas", ".", "remove", "(", "wid", ".", "canvas", ")", "pawncanvas", "=", "(", "self", ".", "board", ".", "spotlayout", ".", "canvas", ".", "before", "if", "canvas", "==", "'before'", "else", "self", ".", "board", ".", "spotlayout", ".", "canvas", ".", "after", "if", "canvas", "==", "'after'", "else", "self", ".", "board", ".", "spotlayout", ".", "canvas", ")", "for", "child", "in", "self", ".", "children", ":", "if", "hasattr", "(", "child", ",", "'group'", ")", "and", "child", ".", "group", "in", "pawncanvas", ".", "children", ":", "pawncanvas", ".", "remove", "(", "child", ".", "group", ")", "pawncanvas", ".", "add", "(", "child", ".", "group", ")", "self", ".", "pospawn", "(", "wid", ")" ]

[ "Put", "the", ":", "class", ":", "Pawn", "at", "a", "point", "along", "my", "length", "proportionate", "to", "how", "close", "it", "is", "to", "finishing", "its", "travel", "through", "me", "." ]

[ "def", "update", "(", "self", ",", "other", ")", ":", "# other is another Sorted Set", "def", "update_sortedset_trans", "(", "pipe", ")", ":", "items", "=", "other", ".", "_data", "(", "pipe", "=", "pipe", ")", "if", "use_redis", "else", "other", ".", "_data", "(", ")", "pipe", ".", "multi", "(", ")", "for", "member", ",", "score", "in", "items", ":", "pipe", ".", "zadd", "(", "self", ".", "key", ",", "{", "self", ".", "_pickle", "(", "member", ")", ":", "float", "(", "score", ")", "}", ")", "# other is dict-like", "def", "update_mapping_trans", "(", "pipe", ")", ":", "items", "=", "other", ".", "items", "(", "pipe", "=", "pipe", ")", "if", "use_redis", "else", "other", ".", "items", "(", ")", "pipe", ".", "multi", "(", ")", "for", "place", ",", "value", "in", "items", ":", "self", ".", "set_location", "(", "place", ",", "value", "[", "'latitude'", "]", ",", "value", "[", "'longitude'", "]", ",", "pipe", "=", "pipe", ")", "# other is a list of tuples", "def", "update_tuples_trans", "(", "pipe", ")", ":", "items", "=", "(", "other", ".", "__iter__", "(", "pipe", "=", "pipe", ")", "if", "use_redis", "else", "other", ".", "__iter__", "(", ")", ")", "pipe", ".", "multi", "(", ")", "for", "place", ",", "latitude", ",", "longitude", "in", "items", ":", "self", ".", "set_location", "(", "place", ",", "latitude", ",", "longitude", ",", "pipe", "=", "pipe", ")", "watches", "=", "[", "]", "if", "self", ".", "_same_redis", "(", "other", ",", "RedisCollection", ")", ":", "use_redis", "=", "True", "watches", ".", "append", "(", "other", ".", "key", ")", "else", ":", "use_redis", "=", "False", "if", "isinstance", "(", "other", ",", "SortedSetBase", ")", ":", "func", "=", "update_sortedset_trans", "elif", "hasattr", "(", "other", ",", "'items'", ")", ":", "func", "=", "update_mapping_trans", "elif", "hasattr", "(", "other", ",", "'__iter__'", ")", ":", "func", "=", "update_tuples_trans", "self", ".", "_transaction", "(", "func", ",", "*", "watches", ")" ]

[ "Update", "the", "collection", "with", "items", "from", "*", "other", "*", ".", "Accepts", "other", ":", "class", ":", "GeoDB", "instances", "dictionaries", "mapping", "places", "to", "{", "latitude", ":", "latitude", "longitude", ":", "longitude", "}", "dicts", "or", "sequences", "of", "(", "place", "latitude", "longitude", ")", "tuples", "." ]

[ "def", "read", "(", "self", ",", "*", "args", ",", "*", "*", "kwargs", ")", ":", "ret", "=", "configparser", ".", "SafeConfigParser", ".", "read", "(", "self", ",", "*", "args", ",", "*", "*", "kwargs", ")", "self", ".", "parse_flask_section", "(", ")", "return", "ret" ]

[ "Overridden", "read", "()", "method", "to", "call", "parse_flask_section", "()", "at", "the", "end" ]

[ "def", "update", "(", "m", ",", "k", ",", "f", ",", "*", "args", ")", ":", "if", "m", "is", "None", ":", "return", "lmap", ".", "Map", ".", "empty", "(", ")", ".", "assoc", "(", "k", ",", "f", "(", "None", ",", "*", "args", ")", ")", "if", "isinstance", "(", "m", ",", "IAssociative", ")", ":", "old_v", "=", "m", ".", "entry", "(", "k", ")", "new_v", "=", "f", "(", "old_v", ",", "*", "args", ")", "return", "m", ".", "assoc", "(", "k", ",", "new_v", ")", "raise", "TypeError", "(", "f\"Object of type {type(m)} does not implement Associative interface\"", ")" ]

[ "Updates", "the", "value", "for", "key", "k", "in", "associative", "data", "structure", "m", "with", "the", "return", "value", "from", "calling", "f", "(", "old_v", "*", "args", ")", ".", "If", "m", "is", "None", "use", "an", "empty", "map", ".", "If", "k", "is", "not", "in", "m", "old_v", "will", "be", "None", "." ]

[ "def", "fit", "(", "self", ",", "X", ",", "y", ",", "*", "*", "fit_params", ")", ":", "return", "default_client", "(", ")", ".", "sync", "(", "self", ".", "_fit", ",", "X", ",", "y", ",", "*", "*", "fit_params", ")" ]

[ "Find", "the", "best", "parameters", "for", "a", "particular", "model", "." ]

[ "def", "_power_mismatch_dc", "(", "self", ",", "buses", ",", "generators", ",", "B", ",", "Pbusinj", ",", "base_mva", ")", ":", "nb", ",", "ng", "=", "len", "(", "buses", ")", ",", "len", "(", "generators", ")", "# Negative bus-generator incidence matrix.", "gen_bus", "=", "array", "(", "[", "g", ".", "bus", ".", "_i", "for", "g", "in", "generators", "]", ")", "neg_Cg", "=", "csr_matrix", "(", "(", "-", "ones", "(", "ng", ")", ",", "(", "gen_bus", ",", "range", "(", "ng", ")", ")", ")", ",", "(", "nb", ",", "ng", ")", ")", "Amis", "=", "hstack", "(", "[", "B", ",", "neg_Cg", "]", ",", "format", "=", "\"csr\"", ")", "Pd", "=", "array", "(", "[", "bus", ".", "p_demand", "for", "bus", "in", "buses", "]", ")", "Gs", "=", "array", "(", "[", "bus", ".", "g_shunt", "for", "bus", "in", "buses", "]", ")", "bmis", "=", "-", "(", "Pd", "-", "Gs", ")", "/", "base_mva", "-", "Pbusinj", "return", "LinearConstraint", "(", "\"Pmis\"", ",", "Amis", ",", "bmis", ",", "bmis", ",", "[", "\"Va\"", ",", "\"Pg\"", "]", ")" ]

[ "Returns", "the", "power", "mismatch", "constraint", "(", "B", "*", "Va", "+", "Pg", "=", "Pd", ")", "." ]

[ "def", "encode_offset_commit_request_kafka", "(", "cls", ",", "group", ",", "payloads", ")", ":", "return", "kafka", ".", "protocol", ".", "commit", ".", "OffsetCommitRequest", "[", "2", "]", "(", "consumer_group", "=", "group", ",", "consumer_group_generation_id", "=", "kafka", ".", "protocol", ".", "commit", ".", "OffsetCommitRequest", "[", "2", "]", ".", "DEFAULT_GENERATION_ID", ",", "consumer_id", "=", "''", ",", "retention_time", "=", "kafka", ".", "protocol", ".", "commit", ".", "OffsetCommitRequest", "[", "2", "]", ".", "DEFAULT_RETENTION_TIME", ",", "topics", "=", "[", "(", "topic", ",", "[", "(", "partition", ",", "payload", ".", "offset", ",", "payload", ".", "metadata", ")", "for", "partition", ",", "payload", "in", "six", ".", "iteritems", "(", "topic_payloads", ")", "]", ")", "for", "topic", ",", "topic_payloads", "in", "six", ".", "iteritems", "(", "group_by_topic_and_partition", "(", "payloads", ")", ")", "]", ")" ]

[ "Encode", "an", "OffsetCommitRequest", "struct", "Arguments", ":", "group", ":", "string", "the", "consumer", "group", "you", "are", "committing", "offsets", "for", "payloads", ":", "list", "of", "OffsetCommitRequestPayload" ]

[ "def", "copy", "(", "self", ",", "order", "=", "\"C\"", ")", ":", "return", "type", "(", "self", ")", "(", "np", ".", "copy", "(", "np", ".", "asarray", "(", "self", ")", ")", ",", "self", ".", "units", ")" ]

[ "Return", "a", "copy", "of", "the", "array", "." ]

[ "def", "conf_merger", "(", "user_dict", ",", "variable", ")", ":", "if", "variable", "not", "in", "globals", "(", ")", ".", "keys", "(", ")", ":", "raise", "NameError", "(", "\"Unknown variable '%s'.\"", "%", "variable", ")", "if", "variable", "not", "in", "user_dict", ":", "return", "globals", "(", ")", "[", "variable", "]", "return", "globals", "(", ")", "[", "variable", "]", "and", "user_dict", "[", "variable", "]" ]

[ "Merge", "global", "configuration", "with", "user", "s", "personal", "configuration", "." ]

[ "def", "y", "(", "self", ",", "*", "args", ",", "*", "*", "kwargs", ")", ":", "thiso", "=", "self", "(", "*", "args", ",", "*", "*", "kwargs", ")", "if", "not", "len", "(", "thiso", ".", "shape", ")", "==", "2", ":", "thiso", "=", "thiso", ".", "reshape", "(", "(", "thiso", ".", "shape", "[", "0", "]", ",", "1", ")", ")", "if", "len", "(", "thiso", "[", ":", ",", "0", "]", ")", "!=", "4", "and", "len", "(", "thiso", "[", ":", ",", "0", "]", ")", "!=", "6", ":", "raise", "AttributeError", "(", "\"orbit must track azimuth to use x()\"", ")", "elif", "len", "(", "thiso", "[", ":", ",", "0", "]", ")", "==", "4", ":", "return", "thiso", "[", "0", ",", ":", "]", "*", "nu", ".", "sin", "(", "thiso", "[", "3", ",", ":", "]", ")", "else", ":", "return", "thiso", "[", "0", ",", ":", "]", "*", "nu", ".", "sin", "(", "thiso", "[", "5", ",", ":", "]", ")" ]

[ "NAME", ":", "y", "PURPOSE", ":", "return", "y", "INPUT", ":", "t", "-", "(", "optional", ")", "time", "at", "which", "to", "get", "y", "ro", "=", "(", "Object", "-", "wide", "default", ")", "physical", "scale", "for", "distances", "to", "use", "to", "convert", "use_physical", "=", "use", "to", "override", "Object", "-", "wide", "default", "for", "using", "a", "physical", "scale", "for", "output", "OUTPUT", ":", "y", "(", "t", ")", "HISTORY", ":", "2010", "-", "09", "-", "21", "-", "Written", "-", "Bovy", "(", "NYU", ")" ]

[ "def", "subtract_column_median", "(", "df", ",", "prefix", "=", "'Intensity '", ")", ":", "df", "=", "df", ".", "copy", "(", ")", "df", ".", "replace", "(", "[", "np", ".", "inf", ",", "-", "np", ".", "inf", "]", ",", "np", ".", "nan", ",", "inplace", "=", "True", ")", "mask", "=", "[", "l", ".", "startswith", "(", "prefix", ")", "for", "l", "in", "df", ".", "columns", ".", "values", "]", "df", ".", "iloc", "[", ":", ",", "mask", "]", "=", "df", ".", "iloc", "[", ":", ",", "mask", "]", "-", "df", ".", "iloc", "[", ":", ",", "mask", "]", ".", "median", "(", "axis", "=", "0", ")", "return", "df" ]

[ "Apply", "column", "-", "wise", "normalisation", "to", "expression", "columns", "." ]

[ "def", "add_item", "(", "self", ",", "jid", ",", "node", "=", "None", ",", "name", "=", "None", ",", "action", "=", "None", ")", ":", "return", "DiscoItem", "(", "self", ",", "jid", ",", "node", ",", "name", ",", "action", ")" ]

[ "Add", "a", "new", "item", "to", "the", "DiscoItems", "object", "." ]

[ "def", "create_environment", "(", "ApplicationName", "=", "None", ",", "EnvironmentName", "=", "None", ",", "GroupName", "=", "None", ",", "Description", "=", "None", ",", "CNAMEPrefix", "=", "None", ",", "Tier", "=", "None", ",", "Tags", "=", "None", ",", "VersionLabel", "=", "None", ",", "TemplateName", "=", "None", ",", "SolutionStackName", "=", "None", ",", "PlatformArn", "=", "None", ",", "OptionSettings", "=", "None", ",", "OptionsToRemove", "=", "None", ")", ":", "pass" ]

[ "Launches", "an", "environment", "for", "the", "specified", "application", "using", "the", "specified", "configuration", ".", "See", "also", ":", "AWS", "API", "Documentation", "Examples", "The", "following", "operation", "creates", "a", "new", "environment", "for", "version", "v1", "of", "a", "java", "application", "named", "my", "-", "app", ":", "Expected", "Output", ":", ":", "example", ":", "response", "=", "client", ".", "create_environment", "(", "ApplicationName", "=", "string", "EnvironmentName", "=", "string", "GroupName", "=", "string", "Description", "=", "string", "CNAMEPrefix", "=", "string", "Tier", "=", "{", "Name", ":", "string", "Type", ":", "string", "Version", ":", "string", "}", "Tags", "=", "[", "{", "Key", ":", "string", "Value", ":", "string", "}", "]", "VersionLabel", "=", "string", "TemplateName", "=", "string", "SolutionStackName", "=", "string", "PlatformArn", "=", "string", "OptionSettings", "=", "[", "{", "ResourceName", ":", "string", "Namespace", ":", "string", "OptionName", ":", "string", "Value", ":", "string", "}", "]", "OptionsToRemove", "=", "[", "{", "ResourceName", ":", "string", "Namespace", ":", "string", "OptionName", ":", "string", "}", "]", ")", ":", "type", "ApplicationName", ":", "string", ":", "param", "ApplicationName", ":", "[", "REQUIRED", "]", "The", "name", "of", "the", "application", "that", "contains", "the", "version", "to", "be", "deployed", ".", "If", "no", "application", "is", "found", "with", "this", "name", "CreateEnvironment", "returns", "an", "InvalidParameterValue", "error", "." ]

[ "def", "validate", "(", "bundle", ")", ":", "errors", "=", "[", "]", "add_error", "=", "errors", ".", "append", "# Check that the bundle sections are well formed.", "series", ",", "services", ",", "machines", ",", "relations", "=", "_validate_sections", "(", "bundle", ",", "add_error", ")", "# If there are errors already, there is no point in proceeding with the", "# validation process.", "if", "errors", ":", "return", "errors", "# Validate each individual section.", "_validate_series", "(", "series", ",", "'bundle'", ",", "add_error", ")", "_validate_services", "(", "services", ",", "machines", ",", "add_error", ")", "_validate_machines", "(", "machines", ",", "add_error", ")", "_validate_relations", "(", "relations", ",", "services", ",", "add_error", ")", "# Return all the collected errors.", "return", "errors" ]

[ "Validate", "a", "bundle", "object", "and", "all", "of", "its", "components", "." ]

[ "def", "save_config", "(", "self", ")", ":", "if", "not", "os", ".", "path", ".", "exists", "(", "self", ".", "_conf_dir", ")", ":", "os", ".", "makedirs", "(", "self", ".", "_conf_dir", ")", "conf_file", "=", "os", ".", "path", ".", "join", "(", "self", ".", "_conf_dir", ",", "\"dql.json\"", ")", "with", "open", "(", "conf_file", ",", "\"w\"", ")", "as", "ofile", ":", "json", ".", "dump", "(", "self", ".", "conf", ",", "ofile", ",", "indent", "=", "2", ")" ]

[ "Save", "the", "conf", "file" ]

[ "def", "can_create_hierarchy_with_record_types", "(", "self", ",", "hierarchy_record_types", ")", ":", "# Implemented from template for", "# osid.resource.BinAdminSession.can_create_bin_with_record_types", "# NOTE: It is expected that real authentication hints will be", "# handled in a service adapter above the pay grade of this impl.", "if", "self", ".", "_catalog_session", "is", "not", "None", ":", "return", "self", ".", "_catalog_session", ".", "can_create_catalog_with_record_types", "(", "catalog_record_types", "=", "hierarchy_record_types", ")", "return", "True" ]

[ "Tests", "if", "this", "user", "can", "create", "a", "single", "Hierarchy", "using", "the", "desired", "record", "types", "." ]

[ "def", "fromXml", "(", "xml", ")", ":", "slide", "=", "XWalkthroughSlide", "(", "*", "*", "xml", ".", "attrib", ")", "# create the items\r", "for", "xgraphic", "in", "xml", ":", "slide", ".", "addItem", "(", "XWalkthroughItem", ".", "fromXml", "(", "xgraphic", ")", ")", "return", "slide" ]

[ "Creates", "a", "new", "slide", "from", "XML", ".", ":", "return", "<XWalkthroughSlide", ">" ]

[ "def", "reassign_port", "(", "self", ",", "port", ")", ":", "body", "=", "{", "'adapter-port-uri'", ":", "port", ".", "uri", "}", "self", ".", "manager", ".", "session", ".", "post", "(", "self", ".", "_uri", "+", "'/operations/reassign-storage-adapter-port'", ",", "body", "=", "body", ")", "self", ".", "properties", ".", "update", "(", "body", ")" ]

[ "Reassign", "this", "HBA", "to", "a", "new", "underlying", ":", "term", ":", "FCP", "port", "." ]

[ "def", "hash_file", "(", "path", ",", "block_size", "=", "65536", ")", ":", "sha256", "=", "hashlib", ".", "sha256", "(", ")", "with", "open", "(", "path", ",", "'rb'", ")", "as", "f", ":", "for", "block", "in", "iter", "(", "lambda", ":", "f", ".", "read", "(", "block_size", ")", ",", "b''", ")", ":", "sha256", ".", "update", "(", "block", ")", "return", "sha256", ".", "hexdigest", "(", ")" ]

[ "Returns", "SHA256", "checksum", "of", "a", "file" ]

[ "def", "getMaxWidth", "(", "self", ",", "rows", ")", ":", "w", "=", "0", "if", "len", "(", "rows", ")", ">", "0", ":", "w", "=", "max", "(", "max", "(", "len", "(", "self", ".", "getDisplayValue", "(", "r", ")", ")", "for", "r", "in", "rows", ")", ",", "len", "(", "self", ".", "name", ")", ")", "+", "2", "return", "max", "(", "w", ",", "len", "(", "self", ".", "name", ")", ")" ]

[ "Return", "the", "maximum", "length", "of", "any", "cell", "in", "column", "or", "its", "header", "." ]

[ "def", "secure_required", "(", "view_func", ")", ":", "def", "_wrapped_view", "(", "request", ",", "*", "args", ",", "*", "*", "kwargs", ")", ":", "if", "not", "request", ".", "is_secure", "(", ")", ":", "if", "getattr", "(", "settings", ",", "'USERENA_USE_HTTPS'", ",", "userena_settings", ".", "DEFAULT_USERENA_USE_HTTPS", ")", ":", "request_url", "=", "request", ".", "build_absolute_uri", "(", "request", ".", "get_full_path", "(", ")", ")", "secure_url", "=", "request_url", ".", "replace", "(", "'http://'", ",", "'https://'", ")", "return", "HttpResponsePermanentRedirect", "(", "secure_url", ")", "return", "view_func", "(", "request", ",", "*", "args", ",", "*", "*", "kwargs", ")", "return", "wraps", "(", "view_func", ",", "assigned", "=", "available_attrs", "(", "view_func", ")", ")", "(", "_wrapped_view", ")" ]

[ "Decorator", "to", "switch", "an", "url", "from", "http", "to", "https", "." ]

[ "def", "_set_session_type", "(", "self", ",", "v", ",", "load", "=", "False", ")", ":", "if", "hasattr", "(", "v", ",", "\"_utype\"", ")", ":", "v", "=", "v", ".", "_utype", "(", "v", ")", "try", ":", "t", "=", "YANGDynClass", "(", "v", ",", "base", "=", "RestrictedClassType", "(", "base_type", "=", "unicode", ",", "restriction_type", "=", "\"dict_key\"", ",", "restriction_arg", "=", "{", "u'session-type-none'", ":", "{", "'value'", ":", "0", "}", ",", "u'merged-backup'", ":", "{", "'value'", ":", "6", "}", ",", "u'ingress-detour'", ":", "{", "'value'", ":", "1", "}", ",", "u'egress-backup'", ":", "{", "'value'", ":", "7", "}", ",", "u'repaired-session'", ":", "{", "'value'", ":", "8", "}", ",", "u'bypass-ingress'", ":", "{", "'value'", ":", "9", "}", ",", "u'transit-detour'", ":", "{", "'value'", ":", "2", "}", ",", "u'egress-detour'", ":", "{", "'value'", ":", "4", "}", ",", "u'ingress-backup'", ":", "{", "'value'", ":", "5", "}", ",", "u'merged-detour'", ":", "{", "'value'", ":", "3", "}", "}", ",", ")", ",", "is_leaf", "=", "True", ",", "yang_name", "=", "\"session-type\"", ",", "rest_name", "=", "\"session-type\"", ",", "parent", "=", "self", ",", "path_helper", "=", "self", ".", "_path_helper", ",", "extmethods", "=", "self", ".", "_extmethods", ",", "register_paths", "=", "True", ",", "namespace", "=", "'urn:brocade.com:mgmt:brocade-mpls-operational'", ",", "defining_module", "=", "'brocade-mpls-operational'", ",", "yang_type", "=", "'session-type'", ",", "is_config", "=", "False", ")", "except", "(", "TypeError", ",", "ValueError", ")", ":", "raise", "ValueError", "(", "{", "'error-string'", ":", "\"\"\"session_type must be of a type compatible with session-type\"\"\"", ",", "'defined-type'", ":", "\"brocade-mpls-operational:session-type\"", ",", "'generated-type'", ":", "\"\"\"YANGDynClass(base=RestrictedClassType(base_type=unicode, restriction_type=\"dict_key\", restriction_arg={u'session-type-none': {'value': 0}, u'merged-backup': {'value': 6}, u'ingress-detour': {'value': 1}, u'egress-backup': {'value': 7}, u'repaired-session': {'value': 8}, u'bypass-ingress': {'value': 9}, u'transit-detour': {'value': 2}, u'egress-detour': {'value': 4}, u'ingress-backup': {'value': 5}, u'merged-detour': {'value': 3}},), is_leaf=True, yang_name=\"session-type\", rest_name=\"session-type\", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='urn:brocade.com:mgmt:brocade-mpls-operational', defining_module='brocade-mpls-operational', yang_type='session-type', is_config=False)\"\"\"", ",", "}", ")", "self", ".", "__session_type", "=", "t", "if", "hasattr", "(", "self", ",", "'_set'", ")", ":", "self", ".", "_set", "(", ")" ]

[ "Setter", "method", "for", "session_type", "mapped", "from", "YANG", "variable", "/", "mpls_state", "/", "rsvp", "/", "sessions", "/", "psbs", "/", "session_type", "(", "session", "-", "type", ")", "If", "this", "variable", "is", "read", "-", "only", "(", "config", ":", "false", ")", "in", "the", "source", "YANG", "file", "then", "_set_session_type", "is", "considered", "as", "a", "private", "method", ".", "Backends", "looking", "to", "populate", "this", "variable", "should", "do", "so", "via", "calling", "thisObj", ".", "_set_session_type", "()", "directly", "." ]

[ "def", "i2c_reply", "(", "self", ",", "data", ")", ":", "reply_data", "=", "[", "]", "address", "=", "(", "data", "[", "0", "]", "&", "0x7f", ")", "+", "(", "data", "[", "1", "]", "<<", "7", ")", "register", "=", "data", "[", "2", "]", "&", "0x7f", "+", "data", "[", "3", "]", "<<", "7", "reply_data", ".", "append", "(", "register", ")", "for", "i", "in", "range", "(", "4", ",", "len", "(", "data", ")", ",", "2", ")", ":", "data_item", "=", "(", "data", "[", "i", "]", "&", "0x7f", ")", "+", "(", "data", "[", "i", "+", "1", "]", "<<", "7", ")", "reply_data", ".", "append", "(", "data_item", ")", "# retrieve the data entry for this address from the i2c map", "if", "address", "in", "self", ".", "i2c_map", ":", "i2c_data", "=", "self", ".", "i2c_map", ".", "get", "(", "address", ",", "None", ")", "i2c_data", "[", "1", "]", "=", "reply_data", "self", ".", "i2c_map", "[", "address", "]", "=", "i2c_data", "# is there a call back for this entry?", "# if yes, return a list of bytes through the callback", "if", "i2c_data", "[", "0", "]", "is", "not", "None", ":", "i2c_data", "[", "0", "]", "(", "[", "self", ".", "pymata", ".", "I2C", ",", "address", ",", "reply_data", "]", ")" ]

[ "This", "method", "receives", "replies", "to", "i2c_read", "requests", ".", "It", "stores", "the", "data", "for", "each", "i2c", "device", "address", "in", "a", "dictionary", "called", "i2c_map", ".", "The", "data", "is", "retrieved", "via", "a", "call", "to", "i2c_get_read_data", "()", "in", "pymata", ".", "py", "It", "a", "callback", "was", "specified", "in", "pymata", ".", "i2c_read", "the", "raw", "data", "is", "sent", "through", "the", "callback" ]

[ "def", "update_payload", "(", "self", ",", "fields", "=", "None", ")", ":", "data", "=", "super", "(", "SyncPlan", ",", "self", ")", ".", "update_payload", "(", "fields", ")", "if", "isinstance", "(", "data", ".", "get", "(", "'sync_date'", ")", ",", "datetime", ")", ":", "data", "[", "'sync_date'", "]", "=", "data", "[", "'sync_date'", "]", ".", "strftime", "(", "'%Y-%m-%d %H:%M:%S'", ")", "return", "data" ]

[ "Convert", "sync_date", "to", "a", "string", "if", "datetime", "object", "provided", "." ]

[ "def", "get_field", "(", "self", ",", "field", ",", "idx", "=", "None", ",", "astype", "=", "None", ")", ":", "assert", "astype", "in", "(", "None", ",", "list", ",", "matrix", ")", "ret", "=", "None", "if", "idx", "is", "None", ":", "idx", "=", "self", ".", "idx", "# ===================disable warning ==============================", "# if field in self._service:", "# logger.warning(", "# 'Reading service variable <{model}.{field}> could be unsafe.'", "# .format(field=field, model=self._name)", "# )", "# =================================================================", "uid", "=", "self", ".", "get_uid", "(", "idx", ")", "field_data", "=", "self", ".", "__dict__", "[", "field", "]", "if", "isinstance", "(", "field_data", ",", "matrix", ")", ":", "ret", "=", "field_data", "[", "uid", "]", "elif", "isinstance", "(", "field_data", ",", "list", ")", ":", "if", "isinstance", "(", "idx", ",", "(", "float", ",", "int", ",", "str", ")", ")", ":", "ret", "=", "field_data", "[", "uid", "]", "else", ":", "ret", "=", "[", "field_data", "[", "x", "]", "for", "x", "in", "uid", "]", "if", "astype", "is", "not", "None", ":", "ret", "=", "astype", "(", "ret", ")", "return", "ret" ]

[ "Return", "self", ".", "field", "for", "the", "elements", "labeled", "by", "idx" ]

[ "def", "properties_dict_for", "(", "self", ",", "index", ")", ":", "props", "=", "self", ".", "properties_for", "(", "index", ")", "prop_index", "=", "extract_properties_to_index", "(", "index", ",", "props", ")", "return", "prop_index" ]

[ "Return", "a", "dictionary", "containing", "properties", "as", "keys", "and", "indices", "as", "index", "Thus", "the", "indices", "for", "each", "constraint", "which", "is", "contained", "will", "be", "collected", "as", "one", "dictionary" ]

[ "def", "_setup", "(", "self", ")", ":", "log", ".", "info", "(", "\"Creating virtualenv for {0}\"", ".", "format", "(", "self", ".", "name", ")", ")", "util", ".", "check_call", "(", "[", "sys", ".", "executable", ",", "\"-mvirtualenv\"", ",", "'--no-site-packages'", ",", "\"-p\"", ",", "self", ".", "_executable", ",", "self", ".", "_path", "]", ")", "log", ".", "info", "(", "\"Installing requirements for {0}\"", ".", "format", "(", "self", ".", "name", ")", ")", "self", ".", "_install_requirements", "(", ")" ]

[ "Setup", "the", "environment", "on", "disk", "using", "virtualenv", ".", "Then", "all", "of", "the", "requirements", "are", "installed", "into", "it", "using", "pip", "install", "." ]

[ "def", "_get_fs", "(", "thin_pathname", ")", ":", "cmd", "=", "[", "'lsblk'", ",", "'-o'", ",", "'FSTYPE'", ",", "'-n'", ",", "thin_pathname", "]", "fs_return", "=", "util", ".", "subp", "(", "cmd", ")", "return", "fs_return", ".", "stdout", ".", "strip", "(", ")" ]

[ "Returns", "the", "file", "system", "type", "(", "xfs", "ext4", ")", "of", "a", "given", "device" ]

[ "async", "def", "_connect", "(", "self", ")", "->", "\"Connection\"", ":", "if", "self", ".", "_connection", "is", "None", ":", "self", ".", "_connection", "=", "await", "self", ".", "_execute", "(", "self", ".", "_connector", ")", "return", "self" ]

[ "Connect", "to", "the", "actual", "sqlite", "database", "." ]

[ "def", "find", "(", "self", ",", "filter", "=", "None", ",", "sort", "=", "None", ",", "skip", "=", "None", ",", "limit", "=", "None", ",", "*", "args", ",", "*", "*", "kwargs", ")", ":", "if", "self", ".", "table", "is", "None", ":", "self", ".", "build_table", "(", ")", "if", "filter", "is", "None", ":", "result", "=", "self", ".", "table", ".", "all", "(", ")", "else", ":", "allcond", "=", "self", ".", "parse_query", "(", "filter", ")", "try", ":", "result", "=", "self", ".", "table", ".", "search", "(", "allcond", ")", "except", "(", "AttributeError", ",", "TypeError", ")", ":", "result", "=", "[", "]", "result", "=", "TinyMongoCursor", "(", "result", ",", "sort", "=", "sort", ",", "skip", "=", "skip", ",", "limit", "=", "limit", ")", "return", "result" ]

[ "Finds", "all", "matching", "results" ]

[ "def", "need_update", "(", "a", ",", "b", ")", ":", "a", "=", "listify", "(", "a", ")", "b", "=", "listify", "(", "b", ")", "return", "any", "(", "(", "not", "op", ".", "exists", "(", "x", ")", ")", "for", "x", "in", "b", ")", "or", "all", "(", "(", "os", ".", "stat", "(", "x", ")", ".", "st_size", "==", "0", "for", "x", "in", "b", ")", ")", "or", "any", "(", "is_newer_file", "(", "x", ",", "y", ")", "for", "x", "in", "a", "for", "y", "in", "b", ")" ]

[ "Check", "if", "file", "a", "is", "newer", "than", "file", "b", "and", "decide", "whether", "or", "not", "to", "update", "file", "b", ".", "Can", "generalize", "to", "two", "lists", "." ]

[ "def", "file_present", "(", "container", ",", "name", ",", "path", ",", "profile", ",", "overwrite_existing", "=", "False", ")", ":", "result", "=", "__salt__", "[", "'libcloud_storage.download_object'", "]", "(", "path", ",", "container", ",", "name", ",", "profile", ",", "overwrite_existing", ")", "return", "state_result", "(", "result", ",", "\"Downloaded object\"", ",", "name", ",", "{", "}", ")" ]

[ "Ensures", "a", "object", "is", "downloaded", "locally", "." ]

[ "def", "cancelar_ultima_venda", "(", "self", ",", "chave_cfe", ",", "dados_cancelamento", ")", ":", "cfe_canc", "=", "dados_cancelamento", "if", "isinstance", "(", "dados_cancelamento", ",", "basestring", ")", "else", "dados_cancelamento", ".", "documento", "(", ")", "return", "self", ".", "invocar__CancelarUltimaVenda", "(", "self", ".", "gerar_numero_sessao", "(", ")", ",", "self", ".", "_codigo_ativacao", ",", "chave_cfe", ",", "cfe_canc", ")" ]

[ "Função", "CancelarUltimaVenda", "conforme", "ER", "SAT", "item", "6", ".", "1", ".", "4", ".", "Envia", "o", "CF", "-", "e", "de", "cancelamento", "para", "o", "equipamento", "SAT", "que", "o", "enviará", "para", "autorização", "e", "cancelamento", "do", "CF", "-", "e", "pela", "SEFAZ", "." ]

[ "def", "motion_cb", "(", "self", ",", "viewer", ",", "button", ",", "data_x", ",", "data_y", ")", ":", "self", ".", "showxy", "(", "viewer", ",", "data_x", ",", "data_y", ")", "return", "True" ]

[ "Motion", "event", "in", "the", "channel", "viewer", "window", ".", "Show", "the", "pointing", "information", "under", "the", "cursor", "." ]

[ "def", "_astore16", "(", "ins", ")", ":", "output", "=", "_addr", "(", "ins", ".", "quad", "[", "1", "]", ")", "op", "=", "ins", ".", "quad", "[", "2", "]", "indirect", "=", "op", "[", "0", "]", "==", "'*'", "if", "indirect", ":", "op", "=", "op", "[", "1", ":", "]", "immediate", "=", "op", "[", "0", "]", "==", "'#'", "if", "immediate", ":", "op", "=", "op", "[", "1", ":", "]", "if", "is_int", "(", "op", ")", ":", "op", "=", "str", "(", "int", "(", "op", ")", "&", "0xFFFF", ")", "# Truncate to 16bit pointer", "if", "indirect", ":", "if", "immediate", ":", "output", ".", "append", "(", "'ld de, (%s)'", "%", "op", ")", "else", ":", "output", ".", "append", "(", "'ld de, (%s)'", "%", "op", ")", "output", ".", "append", "(", "'call __LOAD_DE_DE'", ")", "REQUIRES", ".", "add", "(", "'lddede.asm'", ")", "else", ":", "H", "=", "int", "(", "op", ")", ">>", "8", "L", "=", "int", "(", "op", ")", "&", "0xFF", "output", ".", "append", "(", "'ld (hl), %i'", "%", "L", ")", "output", ".", "append", "(", "'inc hl'", ")", "output", ".", "append", "(", "'ld (hl), %i'", "%", "H", ")", "return", "output", "elif", "op", "[", "0", "]", "==", "'_'", ":", "if", "indirect", ":", "if", "immediate", ":", "output", ".", "append", "(", "'ld de, (%s)'", "%", "op", ")", "# redundant: *#_id == _id", "else", ":", "output", ".", "append", "(", "'ld de, (%s)'", "%", "op", ")", "# *_id", "output", ".", "append", "(", "'call __LOAD_DE_DE'", ")", "REQUIRES", ".", "add", "(", "'lddede.asm'", ")", "else", ":", "if", "immediate", ":", "output", ".", "append", "(", "'ld de, %s'", "%", "op", ")", "else", ":", "output", ".", "append", "(", "'ld de, (%s)'", "%", "op", ")", "else", ":", "output", ".", "append", "(", "'pop de'", ")", "output", ".", "append", "(", "'ld (hl), e'", ")", "output", ".", "append", "(", "'inc hl'", ")", "output", ".", "append", "(", "'ld (hl), d'", ")", "return", "output" ]

[ "Stores", "2º", "operand", "content", "into", "address", "of", "1st", "operand", ".", "store16", "a", "x", "=", ">", "*", "(", "&a", ")", "=", "x", "Use", "*", "for", "indirect", "store", "on", "1st", "operand", "." ]

[ "def", "get_availabilities_for_duration", "(", "duration", ",", "availabilities", ")", ":", "duration_availabilities", "=", "[", "]", "start_time", "=", "'10:00'", "while", "start_time", "!=", "'17:00'", ":", "if", "start_time", "in", "availabilities", ":", "if", "duration", "==", "30", ":", "duration_availabilities", ".", "append", "(", "start_time", ")", "elif", "increment_time_by_thirty_mins", "(", "start_time", ")", "in", "availabilities", ":", "duration_availabilities", ".", "append", "(", "start_time", ")", "start_time", "=", "increment_time_by_thirty_mins", "(", "start_time", ")", "return", "duration_availabilities" ]

[ "Helper", "function", "to", "return", "the", "windows", "of", "availability", "of", "the", "given", "duration", "when", "provided", "a", "set", "of", "30", "minute", "windows", "." ]

[ "def", "_map_input", "(", "self", ",", "input_stream", ")", ":", "for", "record", "in", "self", ".", "reader", "(", "input_stream", ")", ":", "for", "output", "in", "self", ".", "mapper", "(", "*", "record", ")", ":", "yield", "output", "if", "self", ".", "final_mapper", "!=", "NotImplemented", ":", "for", "output", "in", "self", ".", "final_mapper", "(", ")", ":", "yield", "output", "self", ".", "_flush_batch_incr_counter", "(", ")" ]

[ "Iterate", "over", "input", "and", "call", "the", "mapper", "for", "each", "item", ".", "If", "the", "job", "has", "a", "parser", "defined", "the", "return", "values", "from", "the", "parser", "will", "be", "passed", "as", "arguments", "to", "the", "mapper", "." ]

[ "def", "relation_to_role_and_interface", "(", "relation_name", ")", ":", "_metadata", "=", "metadata", "(", ")", "for", "role", "in", "(", "'provides'", ",", "'requires'", ",", "'peers'", ")", ":", "interface", "=", "_metadata", ".", "get", "(", "role", ",", "{", "}", ")", ".", "get", "(", "relation_name", ",", "{", "}", ")", ".", "get", "(", "'interface'", ")", "if", "interface", ":", "return", "role", ",", "interface", "return", "None", ",", "None" ]

[ "Given", "the", "name", "of", "a", "relation", "return", "the", "role", "and", "the", "name", "of", "the", "interface", "that", "relation", "uses", "(", "where", "role", "is", "one", "of", "provides", "requires", "or", "peers", ")", "." ]

[ "def", "resolve", "(", "input", ",", "representation", ",", "resolvers", "=", "None", ",", "*", "*", "kwargs", ")", ":", "resultdict", "=", "query", "(", "input", ",", "representation", ",", "resolvers", ",", "*", "*", "kwargs", ")", "result", "=", "resultdict", "[", "0", "]", "[", "'value'", "]", "if", "resultdict", "else", "None", "if", "result", "and", "len", "(", "result", ")", "==", "1", ":", "result", "=", "result", "[", "0", "]", "return", "result" ]

[ "Resolve", "input", "to", "the", "specified", "output", "representation" ]

[ "def", "get_cameras_signal_strength", "(", "self", ")", ":", "signal_strength", "=", "{", "}", "if", "not", "self", ".", "camera_properties", ":", "return", "None", "for", "camera", "in", "self", ".", "camera_properties", ":", "serialnum", "=", "camera", ".", "get", "(", "'serialNumber'", ")", "cam_strength", "=", "camera", ".", "get", "(", "'signalStrength'", ")", "signal_strength", "[", "serialnum", "]", "=", "cam_strength", "return", "signal_strength" ]

[ "Return", "a", "list", "of", "signal", "strength", "of", "all", "cameras", "." ]

[ "def", "process_alarms", "(", "self", ",", "snmp_data", ")", ":", "self", ".", "active_alarms", "=", "[", "]", "for", "i", "in", "range", "(", "0", ",", "len", "(", "self", ".", "models", "[", "self", ".", "modem_type", "]", "[", "'alarms'", "]", ")", ")", ":", "if", "bool", "(", "int", "(", "snmp_data", "[", "i", "]", ")", ")", "==", "True", ":", "self", ".", "active_alarms", ".", "append", "(", "self", ".", "models", "[", "self", ".", "modem_type", "]", "[", "'alarms'", "]", "[", "i", "]", ")" ]

[ "Build", "list", "with", "active", "alarms" ]

[ "def", "reset_user_attempts", "(", "request", ":", "AxesHttpRequest", ",", "credentials", ":", "dict", "=", "None", ")", "->", "int", ":", "attempts", "=", "filter_user_attempts", "(", "request", ",", "credentials", ")", "count", ",", "_", "=", "attempts", ".", "delete", "(", ")", "log", ".", "info", "(", "'AXES: Reset %s access attempts from database.'", ",", "count", ")", "return", "count" ]

[ "Reset", "all", "user", "attempts", "that", "match", "the", "given", "request", "and", "credentials", "." ]

[ "def", "schemaNewMemParserCtxt", "(", "buffer", ",", "size", ")", ":", "ret", "=", "libxml2mod", ".", "xmlSchemaNewMemParserCtxt", "(", "buffer", ",", "size", ")", "if", "ret", "is", "None", ":", "raise", "parserError", "(", "'xmlSchemaNewMemParserCtxt() failed'", ")", "return", "SchemaParserCtxt", "(", "_obj", "=", "ret", ")" ]

[ "Create", "an", "XML", "Schemas", "parse", "context", "for", "that", "memory", "buffer", "expected", "to", "contain", "an", "XML", "Schemas", "file", "." ]

[ "def", "reverse_id", "(", "self", ")", ":", "return", "'_'", ".", "join", "(", "(", "self", ".", "id", ",", "'reverse'", ",", "hashlib", ".", "md5", "(", "self", ".", "id", ".", "encode", "(", "'utf-8'", ")", ")", ".", "hexdigest", "(", ")", "[", "0", ":", "5", "]", ")", ")" ]

[ "Generate", "the", "id", "of", "reverse_variable", "from", "the", "reaction", "s", "id", "." ]

[ "def", "list_instances", "(", "self", ",", "parent", ",", "page_token", "=", "None", ",", "retry", "=", "google", ".", "api_core", ".", "gapic_v1", ".", "method", ".", "DEFAULT", ",", "timeout", "=", "google", ".", "api_core", ".", "gapic_v1", ".", "method", ".", "DEFAULT", ",", "metadata", "=", "None", ",", ")", ":", "# Wrap the transport method to add retry and timeout logic.", "if", "\"list_instances\"", "not", "in", "self", ".", "_inner_api_calls", ":", "self", ".", "_inner_api_calls", "[", "\"list_instances\"", "]", "=", "google", ".", "api_core", ".", "gapic_v1", ".", "method", ".", "wrap_method", "(", "self", ".", "transport", ".", "list_instances", ",", "default_retry", "=", "self", ".", "_method_configs", "[", "\"ListInstances\"", "]", ".", "retry", ",", "default_timeout", "=", "self", ".", "_method_configs", "[", "\"ListInstances\"", "]", ".", "timeout", ",", "client_info", "=", "self", ".", "_client_info", ",", ")", "request", "=", "bigtable_instance_admin_pb2", ".", "ListInstancesRequest", "(", "parent", "=", "parent", ",", "page_token", "=", "page_token", ")", "if", "metadata", "is", "None", ":", "metadata", "=", "[", "]", "metadata", "=", "list", "(", "metadata", ")", "try", ":", "routing_header", "=", "[", "(", "\"parent\"", ",", "parent", ")", "]", "except", "AttributeError", ":", "pass", "else", ":", "routing_metadata", "=", "google", ".", "api_core", ".", "gapic_v1", ".", "routing_header", ".", "to_grpc_metadata", "(", "routing_header", ")", "metadata", ".", "append", "(", "routing_metadata", ")", "return", "self", ".", "_inner_api_calls", "[", "\"list_instances\"", "]", "(", "request", ",", "retry", "=", "retry", ",", "timeout", "=", "timeout", ",", "metadata", "=", "metadata", ")" ]

[ "Lists", "information", "about", "instances", "in", "a", "project", "." ]

[ "def", "_fetch_socket_data", "(", "self", ",", "parsed_url", ")", ":", "self", ".", "log", ".", "debug", "(", "\"Fetching haproxy stats from socket: %s\"", "%", "parsed_url", ".", "geturl", "(", ")", ")", "if", "parsed_url", ".", "scheme", "==", "'tcp'", ":", "sock", "=", "socket", ".", "socket", "(", "socket", ".", "AF_INET", ",", "socket", ".", "SOCK_STREAM", ")", "splitted_loc", "=", "parsed_url", ".", "netloc", ".", "split", "(", "':'", ")", "host", "=", "splitted_loc", "[", "0", "]", "port", "=", "int", "(", "splitted_loc", "[", "1", "]", ")", "sock", ".", "connect", "(", "(", "host", ",", "port", ")", ")", "else", ":", "sock", "=", "socket", ".", "socket", "(", "socket", ".", "AF_UNIX", ",", "socket", ".", "SOCK_STREAM", ")", "sock", ".", "connect", "(", "parsed_url", ".", "path", ")", "sock", ".", "send", "(", "b\"show stat\\r\\n\"", ")", "response", "=", "\"\"", "output", "=", "sock", ".", "recv", "(", "BUFSIZE", ")", "while", "output", ":", "response", "+=", "output", ".", "decode", "(", "\"ASCII\"", ")", "output", "=", "sock", ".", "recv", "(", "BUFSIZE", ")", "sock", ".", "close", "(", ")", "return", "response", ".", "splitlines", "(", ")" ]

[ "Hit", "a", "given", "stats", "socket", "and", "return", "the", "stats", "lines" ]

[ "def", "sethead", "(", "self", ",", "ref", ")", ":", "log", ".", "debug", "(", "'[%s] Setting to ref %s'", ",", "self", ".", "name", ",", "ref", ")", "try", ":", "ref", "=", "self", ".", "repo", ".", "rev_parse", "(", "ref", ")", "except", "gitdb", ".", "exc", ".", "BadObject", ":", "# Probably means we don't have it cached yet.", "# So maybe we can fetch it.", "ref", "=", "self", ".", "fetchref", "(", "ref", ")", "log", ".", "debug", "(", "'[%s] Setting head to %s'", ",", "self", ".", "name", ",", "ref", ")", "self", ".", "repo", ".", "head", ".", "reset", "(", "ref", ",", "working_tree", "=", "True", ")", "log", ".", "debug", "(", "'[%s] Head object: %s'", ",", "self", ".", "name", ",", "self", ".", "currenthead", ")" ]

[ "Set", "head", "to", "a", "git", "ref", "." ]

[ "def", "transitions_for", "(", "self", ",", "roles", "=", "None", ",", "actor", "=", "None", ",", "anchors", "=", "[", "]", ")", ":", "proxy", "=", "self", ".", "obj", ".", "access_for", "(", "roles", ",", "actor", ",", "anchors", ")", "return", "{", "name", ":", "transition", "for", "name", ",", "transition", "in", "self", ".", "transitions", "(", "current", "=", "False", ")", ".", "items", "(", ")", "if", "name", "in", "proxy", "}" ]

[ "For", "use", "on", ":", "class", ":", "~coaster", ".", "sqlalchemy", ".", "mixins", ".", "RoleMixin", "classes", ":", "returns", "currently", "available", "transitions", "for", "the", "specified", "roles", "or", "actor", "as", "a", "dictionary", "of", "name", ":", ":", "class", ":", "StateTransitionWrapper", "." ]

[ "def", "get_rendered_fields", "(", "self", ",", "ctx", "=", "None", ")", ":", "times", "=", "self", ".", "_min_times", "if", "self", ".", "_mutating", "(", ")", "and", "self", ".", "_in_repeat_stage", "(", ")", ":", "times", "+=", "(", "self", ".", "_current_index", ")", "*", "self", ".", "_step", "return", "super", "(", "Repeat", ",", "self", ")", ".", "get_rendered_fields", "(", "ctx", ")", "*", "times" ]

[ ":", "param", "ctx", ":", "rendering", "context", "in", "which", "the", "method", "was", "called", ":", "return", ":", "ordered", "list", "of", "the", "fields", "that", "will", "be", "rendered" ]

[ "def", "all_valid_time_intervals", "(", ")", ":", "return", "[", "PerformanceTimeInterval", ".", "DAY", ",", "PerformanceTimeInterval", ".", "WEEK", ",", "PerformanceTimeInterval", ".", "TWO_WEEKS", ",", "PerformanceTimeInterval", ".", "SIXTY_DAYS", ",", "PerformanceTimeInterval", ".", "NINETY_DAYS", ",", "PerformanceTimeInterval", ".", "ONE_YEAR", "]" ]

[ "Helper", "method", "to", "return", "all", "possible", "valid", "time", "intervals", "for", "data", "stored", "by", "Perfherder" ]

[ "def", "put", "(", "self", ",", "entity", ")", ":", "if", "self", ".", "_status", "!=", "self", ".", "_IN_PROGRESS", ":", "raise", "ValueError", "(", "\"Batch must be in progress to put()\"", ")", "if", "entity", ".", "key", "is", "None", ":", "raise", "ValueError", "(", "\"Entity must have a key\"", ")", "if", "self", ".", "project", "!=", "entity", ".", "key", ".", "project", ":", "raise", "ValueError", "(", "\"Key must be from same project as batch\"", ")", "if", "entity", ".", "key", ".", "is_partial", ":", "entity_pb", "=", "self", ".", "_add_partial_key_entity_pb", "(", ")", "self", ".", "_partial_key_entities", ".", "append", "(", "entity", ")", "else", ":", "entity_pb", "=", "self", ".", "_add_complete_key_entity_pb", "(", ")", "_assign_entity_to_pb", "(", "entity_pb", ",", "entity", ")" ]

[ "Remember", "an", "entity", "s", "state", "to", "be", "saved", "during", ":", "meth", ":", "commit", "." ]

[ "def", "on_drag_data_received", "(", "self", ",", "widget", ",", "context", ",", "x", ",", "y", ",", "data", ",", "info", ",", "time", ")", ":", "if", "not", "data", ":", "return", "bx", ",", "by", "=", "self", ".", "iconview", ".", "convert_widget_to_bin_window_coords", "(", "x", ",", "y", ")", "selected", "=", "Gtk", ".", "TreeView", ".", "get_path_at_pos", "(", "self", ".", "iconview", ",", "bx", ",", "by", ")", "if", "not", "selected", ":", "return", "tree_path", "=", "selected", "[", "0", "]", "if", "tree_path", "is", "None", ":", "return", "target_path", "=", "self", ".", "liststore", "[", "tree_path", "]", "[", "PATH_COL", "]", "is_dir", "=", "self", ".", "liststore", "[", "tree_path", "]", "[", "ISDIR_COL", "]", "if", "not", "is_dir", "or", "info", "!=", "TargetInfo", ".", "PLAIN_TEXT", ":", "return", "filelist_str", "=", "data", ".", "get_text", "(", ")", "filelist", "=", "json", ".", "loads", "(", "filelist_str", ")", "for", "file_item", "in", "filelist", ":", "if", "file_item", "[", "'path'", "]", "==", "target_path", ":", "self", ".", "app", ".", "toast", "(", "_", "(", "'Error: Move folder to itself!'", ")", ")", "return", "for", "file_item", "in", "filelist", ":", "file_item", "[", "'dest'", "]", "=", "target_path", "gutil", ".", "async_call", "(", "pcs", ".", "move", ",", "self", ".", "app", ".", "cookie", ",", "self", ".", "app", ".", "tokens", ",", "filelist", ",", "callback", "=", "self", ".", "parent", ".", "reload", ")" ]

[ "拖放结束" ]

[ "def", "check_domain", "(", "self", ",", "service_id", ",", "version_number", ",", "name", ")", ":", "content", "=", "self", ".", "_fetch", "(", "\"/service/%s/version/%d/domain/%s/check\"", "%", "(", "service_id", ",", "version_number", ",", "name", ")", ")", "return", "FastlyDomainCheck", "(", "self", ",", "content", ")" ]

[ "Checks", "the", "status", "of", "a", "domain", "s", "DNS", "record", ".", "Returns", "an", "array", "of", "3", "items", ".", "The", "first", "is", "the", "details", "for", "the", "domain", ".", "The", "second", "is", "the", "current", "CNAME", "of", "the", "domain", ".", "The", "third", "is", "a", "boolean", "indicating", "whether", "or", "not", "it", "has", "been", "properly", "setup", "to", "use", "Fastly", "." ]

[ "def", "convert_field", "(", "self", ",", "name", ",", "field", ")", ":", "if", "PEEWEE3", ":", "field_type", "=", "field", ".", "field_type", ".", "lower", "(", ")", "else", ":", "field_type", "=", "field", ".", "db_field", "pwv_field", "=", "ModelValidator", ".", "FIELD_MAP", ".", "get", "(", "field_type", ",", "StringField", ")", "print", "(", "'pwv_field'", ",", "field_type", ",", "pwv_field", ")", "validators", "=", "[", "]", "required", "=", "not", "bool", "(", "getattr", "(", "field", ",", "'null'", ",", "True", ")", ")", "choices", "=", "getattr", "(", "field", ",", "'choices'", ",", "(", ")", ")", "default", "=", "getattr", "(", "field", ",", "'default'", ",", "None", ")", "max_length", "=", "getattr", "(", "field", ",", "'max_length'", ",", "None", ")", "unique", "=", "getattr", "(", "field", ",", "'unique'", ",", "False", ")", "if", "required", ":", "validators", ".", "append", "(", "validate_required", "(", ")", ")", "if", "choices", ":", "print", "(", "'CHOICES'", ",", "choices", ")", "validators", ".", "append", "(", "validate_one_of", "(", "[", "c", "[", "0", "]", "for", "c", "in", "choices", "]", ")", ")", "if", "max_length", ":", "validators", ".", "append", "(", "validate_length", "(", "high", "=", "max_length", ")", ")", "if", "unique", ":", "validators", ".", "append", "(", "validate_model_unique", "(", "field", ",", "self", ".", "instance", ".", "select", "(", ")", ",", "self", ".", "pk_field", ",", "self", ".", "pk_value", ")", ")", "if", "isinstance", "(", "field", ",", "peewee", ".", "ForeignKeyField", ")", ":", "if", "PEEWEE3", ":", "rel_field", "=", "field", ".", "rel_field", "else", ":", "rel_field", "=", "field", ".", "to_field", "return", "ModelChoiceField", "(", "field", ".", "rel_model", ",", "rel_field", ",", "default", "=", "default", ",", "validators", "=", "validators", ")", "if", "isinstance", "(", "field", ",", "ManyToManyField", ")", ":", "return", "ManyModelChoiceField", "(", "field", ".", "rel_model", ",", "field", ".", "rel_model", ".", "_meta", ".", "primary_key", ",", "default", "=", "default", ",", "validators", "=", "validators", ")", "return", "pwv_field", "(", "default", "=", "default", ",", "validators", "=", "validators", ")" ]

[ "Convert", "a", "single", "field", "from", "a", "Peewee", "model", "field", "to", "a", "validator", "field", "." ]

[ "def", "get_repo", "(", "repo", ",", "*", "*", "kwargs", ")", ":", "# pylint: disable=unused-argument", "repos", "=", "list_repos", "(", ")", "if", "repos", ":", "for", "source", "in", "six", ".", "itervalues", "(", "repos", ")", ":", "for", "sub", "in", "source", ":", "if", "sub", "[", "'name'", "]", "==", "repo", ":", "return", "sub", "return", "{", "}" ]

[ "Display", "a", "repo", "from", "the", "/", "etc", "/", "opkg", "/", "*", ".", "conf" ]

[ "def", "describe_training_job_with_log", "(", "self", ",", "job_name", ",", "positions", ",", "stream_names", ",", "instance_count", ",", "state", ",", "last_description", ",", "last_describe_job_call", ")", ":", "log_group", "=", "'/aws/sagemaker/TrainingJobs'", "if", "len", "(", "stream_names", ")", "<", "instance_count", ":", "# Log streams are created whenever a container starts writing to stdout/err, so this list", "# may be dynamic until we have a stream for every instance.", "logs_conn", "=", "self", ".", "get_log_conn", "(", ")", "try", ":", "streams", "=", "logs_conn", ".", "describe_log_streams", "(", "logGroupName", "=", "log_group", ",", "logStreamNamePrefix", "=", "job_name", "+", "'/'", ",", "orderBy", "=", "'LogStreamName'", ",", "limit", "=", "instance_count", ")", "stream_names", "=", "[", "s", "[", "'logStreamName'", "]", "for", "s", "in", "streams", "[", "'logStreams'", "]", "]", "positions", ".", "update", "(", "[", "(", "s", ",", "Position", "(", "timestamp", "=", "0", ",", "skip", "=", "0", ")", ")", "for", "s", "in", "stream_names", "if", "s", "not", "in", "positions", "]", ")", "except", "logs_conn", ".", "exceptions", ".", "ResourceNotFoundException", ":", "# On the very first training job run on an account, there's no log group until", "# the container starts logging, so ignore any errors thrown about that", "pass", "if", "len", "(", "stream_names", ")", ">", "0", ":", "for", "idx", ",", "event", "in", "self", ".", "multi_stream_iter", "(", "log_group", ",", "stream_names", ",", "positions", ")", ":", "self", ".", "log", ".", "info", "(", "event", "[", "'message'", "]", ")", "ts", ",", "count", "=", "positions", "[", "stream_names", "[", "idx", "]", "]", "if", "event", "[", "'timestamp'", "]", "==", "ts", ":", "positions", "[", "stream_names", "[", "idx", "]", "]", "=", "Position", "(", "timestamp", "=", "ts", ",", "skip", "=", "count", "+", "1", ")", "else", ":", "positions", "[", "stream_names", "[", "idx", "]", "]", "=", "Position", "(", "timestamp", "=", "event", "[", "'timestamp'", "]", ",", "skip", "=", "1", ")", "if", "state", "==", "LogState", ".", "COMPLETE", ":", "return", "state", ",", "last_description", ",", "last_describe_job_call", "if", "state", "==", "LogState", ".", "JOB_COMPLETE", ":", "state", "=", "LogState", ".", "COMPLETE", "elif", "time", ".", "time", "(", ")", "-", "last_describe_job_call", ">=", "30", ":", "description", "=", "self", ".", "describe_training_job", "(", "job_name", ")", "last_describe_job_call", "=", "time", ".", "time", "(", ")", "if", "secondary_training_status_changed", "(", "description", ",", "last_description", ")", ":", "self", ".", "log", ".", "info", "(", "secondary_training_status_message", "(", "description", ",", "last_description", ")", ")", "last_description", "=", "description", "status", "=", "description", "[", "'TrainingJobStatus'", "]", "if", "status", "not", "in", "self", ".", "non_terminal_states", ":", "state", "=", "LogState", ".", "JOB_COMPLETE", "return", "state", ",", "last_description", ",", "last_describe_job_call" ]

[ "Return", "the", "training", "job", "info", "associated", "with", "job_name", "and", "print", "CloudWatch", "logs" ]

[ "def", "__cutRaw", "(", "self", ",", "oiraw", ",", "maxLength", ")", ":", "vec", "=", "[", "]", "m", "=", "re", ".", "findall", "(", "u\".*?[。？！；;!?]\", oiraw)", "", "", "", "num", ",", "l", ",", "last", "=", "0", ",", "0", ",", "0", "for", "i", "in", "range", "(", "len", "(", "m", ")", ")", ":", "if", "(", "num", "+", "len", "(", "m", "[", "i", "]", ")", ">=", "maxLength", ")", ":", "vec", ".", "append", "(", "\"\"", ".", "join", "(", "m", "[", "last", ":", "i", "]", ")", ")", "last", "=", "i", "num", "=", "len", "(", "m", "[", "i", "]", ")", "else", ":", "num", "+=", "len", "(", "m", "[", "i", "]", ")", "l", "+=", "len", "(", "m", "[", "i", "]", ")", "if", "(", "len", "(", "oiraw", ")", "-", "l", "+", "num", ">=", "maxLength", ")", ":", "vec", ".", "append", "(", "\"\"", ".", "join", "(", "m", "[", "last", ":", "len", "(", "m", ")", "]", ")", ")", "vec", ".", "append", "(", "oiraw", "[", "l", ":", "]", ")", "else", ":", "vec", ".", "append", "(", "oiraw", "[", "l", "-", "num", ":", "]", ")", "return", "vec" ]

[ "现将句子按句子完结符号切分，如果切分完后一个句子长度超过限定值", "，再对该句子进行切分" ]