Datasets:

---

kejian

/

codesearchnet-python-raw

like 1

[ "async", "def", "_deferred_init", "(", "self", ")", ":", "await", "self", ".", "_check_subscriptions", "(", ")", "await", "self", ".", "_set_whitelist", "(", ")", "await", "self", ".", "_set_get_started", "(", ")", "await", "self", ".", "_set_greeting_text", "(", ")", "await", "self", ".", "_set_persistent_menu", "(", ")" ]

[ "Run", "those", "things", "in", "a", "sepearate", "tasks", "as", "they", "are", "not", "required", "for", "the", "bot", "to", "work", "and", "they", "take", "a", "lot", "of", "time", "to", "run", "." ]

[ "def", "do_ls", "(", "self", ",", "line", ")", ":", "args", "=", "self", ".", "line_to_args", "(", "line", ")", "if", "len", "(", "args", ".", "filenames", ")", "==", "0", ":", "args", ".", "filenames", "=", "[", "'.'", "]", "for", "idx", ",", "fn", "in", "enumerate", "(", "args", ".", "filenames", ")", ":", "if", "not", "is_pattern", "(", "fn", ")", ":", "filename", "=", "resolve_path", "(", "fn", ")", "stat", "=", "auto", "(", "get_stat", ",", "filename", ")", "mode", "=", "stat_mode", "(", "stat", ")", "if", "not", "mode_exists", "(", "mode", ")", ":", "err", "=", "\"Cannot access '{}': No such file or directory\"", "print_err", "(", "err", ".", "format", "(", "filename", ")", ")", "continue", "if", "not", "mode_isdir", "(", "mode", ")", ":", "if", "args", ".", "long", ":", "print_long", "(", "fn", ",", "stat", ",", "self", ".", "print", ")", "else", ":", "self", ".", "print", "(", "fn", ")", "continue", "if", "len", "(", "args", ".", "filenames", ")", ">", "1", ":", "if", "idx", ">", "0", ":", "self", ".", "print", "(", "''", ")", "self", ".", "print", "(", "\"%s:\"", "%", "filename", ")", "pattern", "=", "'*'", "else", ":", "# A pattern was specified", "filename", ",", "pattern", "=", "validate_pattern", "(", "fn", ")", "if", "filename", "is", "None", ":", "# An error was printed", "continue", "files", "=", "[", "]", "ldir_stat", "=", "auto", "(", "listdir_stat", ",", "filename", ")", "if", "ldir_stat", "is", "None", ":", "err", "=", "\"Cannot access '{}': No such file or directory\"", "print_err", "(", "err", ".", "format", "(", "filename", ")", ")", "else", ":", "for", "filename", ",", "stat", "in", "sorted", "(", "ldir_stat", ",", "key", "=", "lambda", "entry", ":", "entry", "[", "0", "]", ")", ":", "if", "is_visible", "(", "filename", ")", "or", "args", ".", "all", ":", "if", "fnmatch", ".", "fnmatch", "(", "filename", ",", "pattern", ")", ":", "if", "args", ".", "long", ":", "print_long", "(", "filename", ",", "stat", ",", "self", ".", "print", ")", "else", ":", "files", ".", "append", "(", "decorated_filename", "(", "filename", ",", "stat", ")", ")", "if", "len", "(", "files", ")", ">", "0", ":", "print_cols", "(", "sorted", "(", "files", ")", ",", "self", ".", "print", ",", "self", ".", "columns", ")" ]

[ "ls", "[", "-", "a", "]", "[", "-", "l", "]", "[", "FILE|DIRECTORY|PATTERN", "]", "...", "PATTERN", "supports", "*", "?", "[", "seq", "]", "[", "!seq", "]", "Unix", "filename", "matching" ]

[ "def", "correct_dm", "(", "d", ",", "dm", ",", "blrange", ")", ":", "data", "=", "numpyview", "(", "data_mem", ",", "'complex64'", ",", "datashape", "(", "d", ")", ")", "data_resamp", "=", "numpyview", "(", "data_resamp_mem", ",", "'complex64'", ",", "datashape", "(", "d", ")", ")", "bl0", ",", "bl1", "=", "blrange", "data_resamp", "[", ":", ",", "bl0", ":", "bl1", "]", "=", "data", "[", ":", ",", "bl0", ":", "bl1", "]", "rtlib", ".", "dedisperse_par", "(", "data_resamp", ",", "d", "[", "'freq'", "]", ",", "d", "[", "'inttime'", "]", ",", "dm", ",", "blrange", ",", "verbose", "=", "0", ")" ]

[ "Dedisperses", "data", "into", "data_resamp", "Drops", "edges", "since", "it", "assumes", "that", "data", "is", "read", "with", "overlapping", "chunks", "in", "time", "." ]

[ "def", "raw_abundance", "(", "biomf", ",", "sampleIDs", "=", "None", ",", "sample_abd", "=", "True", ")", ":", "results", "=", "defaultdict", "(", "int", ")", "if", "sampleIDs", "is", "None", ":", "sampleIDs", "=", "biomf", ".", "ids", "(", ")", "else", ":", "try", ":", "for", "sid", "in", "sampleIDs", ":", "assert", "sid", "in", "biomf", ".", "ids", "(", ")", "except", "AssertionError", ":", "raise", "ValueError", "(", "\"\\nError while calculating raw total abundances: The sampleIDs provided \"", "\"do not match the sampleIDs in biom file. Please double check the \"", "\"sampleIDs provided.\\n\"", ")", "otuIDs", "=", "biomf", ".", "ids", "(", "axis", "=", "\"observation\"", ")", "for", "sampleID", "in", "sampleIDs", ":", "for", "otuID", "in", "otuIDs", ":", "abd", "=", "biomf", ".", "get_value_by_ids", "(", "otuID", ",", "sampleID", ")", "if", "sample_abd", ":", "results", "[", "sampleID", "]", "+=", "abd", "else", ":", "results", "[", "otuID", "]", "+=", "abd", "return", "results" ]

[ "Calculate", "the", "total", "number", "of", "sequences", "in", "each", "OTU", "or", "SampleID", "." ]

[ "def", "_init_transforms", "(", "self", ",", "subjs", ",", "voxels", ",", "features", ",", "random_state", ")", ":", "# Init the Random seed generator", "np", ".", "random", ".", "seed", "(", "self", ".", "rand_seed", ")", "# Draw a random W for each subject", "W", "=", "[", "random_state", ".", "random_sample", "(", "(", "voxels", "[", "i", "]", ",", "features", ")", ")", "for", "i", "in", "range", "(", "subjs", ")", "]", "# Make it orthogonal it with QR decomposition", "for", "i", "in", "range", "(", "subjs", ")", ":", "W", "[", "i", "]", ",", "_", "=", "np", ".", "linalg", ".", "qr", "(", "W", "[", "i", "]", ")", "return", "W" ]

[ "Initialize", "the", "mappings", "(", "Wi", ")", "with", "random", "orthogonal", "matrices", ".", "Parameters", "----------" ]

[ "def", "check_status", "(", "content", ",", "response", ")", ":", "if", "response", ".", "status", "==", "400", ":", "raise", "MalformedRequestException", "(", "content", ",", "response", ")", "if", "response", ".", "status", "==", "401", ":", "raise", "UnauthorisedException", "(", "content", ",", "response", ")", "if", "response", ".", "status", "==", "404", ":", "raise", "NotFoundException", "(", "content", ",", "response", ")", "if", "response", ".", "status", "==", "406", ":", "raise", "UnacceptableContentException", "(", "content", ",", "response", ")", "if", "response", ".", "status", "==", "422", ":", "raise", "InvalidRequestException", "(", "content", ",", "response", ")", "if", "response", ".", "status", "==", "429", ":", "raise", "RateLimitException", "(", "content", ",", "response", ")", "if", "response", ".", "status", ">=", "500", ":", "raise", "ServerException", "(", "content", ",", "response", ")" ]

[ "Check", "the", "response", "that", "is", "returned", "for", "known", "exceptions", "and", "errors", ".", ":", "param", "response", ":", "Response", "that", "is", "returned", "from", "the", "call", ".", ":", "raise", ":", "MalformedRequestException", "if", "response", ".", "status", "is", "400", "UnauthorisedException", "if", "response", ".", "status", "is", "401", "NotFoundException", "if", "response", ".", "status", "is", "404", "UnacceptableContentException", "if", "response", ".", "status", "is", "406", "InvalidRequestException", "if", "response", ".", "status", "is", "422", "RateLimitException", "if", "response", ".", "status", "is", "429", "ServerException", "if", "response", ".", "status", ">", "500" ]

[ "def", "_parse_version", "(", "self", ",", "line", ")", ":", "version_string", "=", "line", ".", "split", "(", "' '", ")", "[", "1", "]", "version_list", "=", "version_string", ".", "split", "(", "'.'", ")", "major_version", "=", "''", ".", "join", "(", "[", "version_list", "[", "0", "]", ",", "version_list", "[", "1", "]", "]", ")", "release_num", "=", "''", ".", "join", "(", "[", "version_list", "[", "2", "]", ".", "rstrip", "(", ")", ",", "\"-03\"", "]", ")", "return", "(", "major_version", ",", "release_num", ")" ]

[ "There", "s", "a", "magic", "suffix", "to", "the", "release", "version", "currently", "it", "s", "-", "03", "but", "it", "increments", "seemingly", "randomly", "." ]

[ "def", "index", "(", ")", ":", "page", "=", "request", ".", "values", ".", "get", "(", "'page'", ",", "1", ",", "type", "=", "int", ")", "size", "=", "request", ".", "values", ".", "get", "(", "'size'", ",", "2", ",", "type", "=", "int", ")", "search", "=", "ExampleSearch", "(", ")", "[", "(", "page", "-", "1", ")", "*", "size", ":", "page", "*", "size", "]", "if", "'q'", "in", "request", ".", "values", ":", "search", "=", "search", ".", "query", "(", "QueryString", "(", "query", "=", "request", ".", "values", ".", "get", "(", "'q'", ")", ")", ")", "search", "=", "search", ".", "sort", "(", "request", ".", "values", ".", "get", "(", "'sort'", ",", "'title'", ")", ")", "search", "=", "ExampleSearch", ".", "faceted_search", "(", "search", "=", "search", ")", "results", "=", "search", ".", "execute", "(", ")", ".", "to_dict", "(", ")", "return", "jsonify", "(", "{", "'hits'", ":", "results", ".", "get", "(", "'hits'", ")", "}", ")" ]

[ "Query", "Elasticsearch", "using", "Invenio", "query", "syntax", "." ]

[ "def", "apply", "(", "self", ",", "builder", ",", "model", ")", ":", "builder", ".", "where_null", "(", "model", ".", "get_qualified_deleted_at_column", "(", ")", ")", "self", ".", "extend", "(", "builder", ")" ]

[ "Apply", "the", "scope", "to", "a", "given", "query", "builder", "." ]

[ "def", "filtered_data", "(", "self", ",", "pin", ")", ":", "assert", "pin", ">=", "0", "and", "pin", "<", "12", ",", "'pin must be between 0-11 (inclusive)'", "return", "self", ".", "_i2c_retry", "(", "self", ".", "_device", ".", "readU16LE", ",", "MPR121_FILTDATA_0L", "+", "pin", "*", "2", ")" ]

[ "Return", "filtered", "data", "register", "value", "for", "the", "provided", "pin", "(", "0", "-", "11", ")", ".", "Useful", "for", "debugging", "." ]

[ "def", "remove_s3_bucket", "(", ")", ":", "logger", ".", "debug", "(", "\"[#] Removing S3 bucket\"", ")", "client", "=", "boto3", ".", "client", "(", "\"s3\"", ",", "region_name", "=", "PRIMARY_REGION", ")", "buckets", "=", "client", ".", "list_buckets", "(", ")", "matches", "=", "[", "x", "for", "x", "in", "buckets", ".", "get", "(", "'Buckets'", ",", "list", "(", ")", ")", "if", "x", "[", "'Name'", "]", ".", "startswith", "(", "S3_BUCKET_NAME", ")", "]", "if", "len", "(", "matches", ")", "==", "0", ":", "return", "match", "=", "matches", ".", "pop", "(", ")", "[", "'Name'", "]", "try", ":", "response", "=", "client", ".", "list_objects_v2", "(", "Bucket", "=", "match", ",", ")", "except", "client", ".", "exceptions", ".", "NoSuchBucket", ":", "logger", ".", "info", "(", "\"[!] S3 bucket already deleted\"", ")", "return", "True", "while", "response", "[", "'KeyCount'", "]", ">", "0", ":", "logger", ".", "debug", "(", "'[*] Deleting %d objects from bucket %s'", "%", "(", "len", "(", "response", "[", "'Contents'", "]", ")", ",", "match", ")", ")", "response", "=", "client", ".", "delete_objects", "(", "Bucket", "=", "match", ",", "Delete", "=", "{", "'Objects'", ":", "[", "{", "'Key'", ":", "obj", "[", "'Key'", "]", "}", "for", "obj", "in", "response", "[", "'Contents'", "]", "]", "}", ")", "response", "=", "client", ".", "list_objects_v2", "(", "Bucket", "=", "match", ",", ")", "logger", ".", "debug", "(", "'[#] Deleting bucket %s'", "%", "match", ")", "response", "=", "client", ".", "delete_bucket", "(", "Bucket", "=", "match", ")", "logger", ".", "info", "(", "\"[#] Successfully deleted the S3 bucket\"", ")", "return", "response" ]

[ "Remove", "the", "Blockade", "bucket", "." ]

[ "def", "gen_subcommand_help", "(", "self", ")", ":", "commands", "=", "sorted", "(", "self", ".", "subcommands", ".", "items", "(", ")", ",", "key", "=", "lambda", "i", ":", "i", "[", "0", "]", ")", "return", "'\\n'", ".", "join", "(", "'%s %s'", "%", "(", "subcommand", ".", "ljust", "(", "15", ")", ",", "textwrap", ".", "shorten", "(", "description", ",", "width", "=", "61", ")", ",", ")", "for", "subcommand", ",", "(", "description", ",", "action", ",", "opts", ")", "in", "commands", ")" ]

[ "Generates", "s" ]

[ "def", "detectEncodingMeta", "(", "self", ")", ":", "buffer", "=", "self", ".", "rawStream", ".", "read", "(", "self", ".", "numBytesMeta", ")", "assert", "isinstance", "(", "buffer", ",", "bytes", ")", "parser", "=", "EncodingParser", "(", "buffer", ")", "self", ".", "rawStream", ".", "seek", "(", "0", ")", "encoding", "=", "parser", ".", "getEncoding", "(", ")", "if", "encoding", "is", "not", "None", "and", "encoding", ".", "name", "in", "(", "\"utf-16be\"", ",", "\"utf-16le\"", ")", ":", "encoding", "=", "lookupEncoding", "(", "\"utf-8\"", ")", "return", "encoding" ]

[ "Report", "the", "encoding", "declared", "by", "the", "meta", "element" ]

[ "def", "rename_xmlids", "(", "cr", ",", "xmlids_spec", ")", ":", "for", "(", "old", ",", "new", ")", "in", "xmlids_spec", ":", "if", "'.'", "not", "in", "old", "or", "'.'", "not", "in", "new", ":", "logger", ".", "error", "(", "'Cannot rename XMLID %s to %s: need the module '", "'reference to be specified in the IDs'", "%", "(", "old", ",", "new", ")", ")", "else", ":", "query", "=", "(", "\"UPDATE ir_model_data SET module = %s, name = %s \"", "\"WHERE module = %s and name = %s\"", ")", "logged_query", "(", "cr", ",", "query", ",", "tuple", "(", "new", ".", "split", "(", "'.'", ")", "+", "old", ".", "split", "(", "'.'", ")", ")", ")" ]

[ "Rename", "XML", "IDs", ".", "Typically", "called", "in", "the", "pre", "script", ".", "One", "usage", "example", "is", "when", "an", "ID", "changes", "module", ".", "In", "OpenERP", "6", "for", "example", "a", "number", "of", "res_groups", "IDs", "moved", "to", "module", "base", "from", "other", "modules", "(", "although", "they", "were", "still", "being", "defined", "in", "their", "respective", "module", ")", "." ]

[ "def", "distance", "(", "self", ",", "sources", ",", "destinations", ",", "x", "=", "'x'", ",", "y", "=", "'y'", ",", "isolation", "=", "True", ",", "export_raster", "=", "False", ",", "export_shape", "=", "False", ",", "routes", "=", "False", ",", "path", "=", "'./'", ")", ":", "start_points", "=", "sources", ".", "copy", "(", ")", "end_points", "=", "destinations", ".", "copy", "(", ")", "if", "(", "not", "isinstance", "(", "start_points", ",", "pd", ".", "core", ".", "frame", ".", "DataFrame", ")", "and", "not", "isinstance", "(", "start_points", ",", "gp", ".", "geodataframe", ".", "GeoDataFrame", ")", ")", ":", "raise", "TypeError", "(", "'Sources has to be a (Geo)Pandas Data Frame Object.'", ")", "if", "(", "not", "isinstance", "(", "end_points", ",", "pd", ".", "core", ".", "frame", ".", "DataFrame", ")", "and", "not", "isinstance", "(", "end_points", ",", "gp", ".", "geodataframe", ".", "GeoDataFrame", ")", ")", ":", "raise", "TypeError", "(", "'Destinations has to be a (Geo)Pandas Data Frame Object.'", ")", "if", "not", "self", ".", "mcp_cost", ":", "self", ".", "mcp", "(", ")", "count", "=", "0", "start_points", "[", "'row'", "]", ",", "start_points", "[", "'col'", "]", "=", "self", ".", "map_pixel_location", "(", "start_points", "[", "x", "]", ",", "start_points", "[", "y", "]", ")", "end_points", "[", "'row'", "]", ",", "end_points", "[", "'col'", "]", "=", "self", ".", "map_pixel_location", "(", "end_points", "[", "x", "]", ",", "end_points", "[", "y", "]", ")", "start_points", "[", "'ID'", "]", "=", "start_points", ".", "index", ".", "values", "end_points", "[", "'ID'", "]", "=", "end_points", ".", "index", ".", "values", "+", "start_points", "[", "'ID'", "]", ".", "max", "(", ")", "+", "1", "for", "i", "in", "start_points", ".", "iterrows", "(", ")", ":", "cumulative_costs", ",", "traceback", "=", "self", ".", "mcp_cost", ".", "find_costs", "(", "[", "[", "i", "[", "1", "]", ".", "row", ",", "i", "[", "1", "]", ".", "col", "]", "]", ")", "dist", "=", "cumulative_costs", "[", "end_points", ".", "row", ".", "values", ",", "end_points", ".", "col", ".", "values", "]", ".", "transpose", "(", ")", "/", "(", "7", "*", "24", ")", "df2", "=", "pd", ".", "DataFrame", "(", "np", ".", "array", "(", "[", "(", "i", "[", "1", "]", "[", "'ID'", "]", "*", "np", ".", "ones_like", "(", "dist", ")", ")", ".", "flatten", "(", ")", ",", "end_points", "[", "'ID'", "]", ",", "dist", ".", "flatten", "(", ")", "]", ")", ".", "transpose", "(", ")", ",", "columns", "=", "[", "'ID1'", ",", "'ID2'", ",", "'dist'", "]", ")", "# Keep only locations that are accessible", "df2", "=", "df2", ".", "loc", "[", "df2", "[", "'dist'", "]", "<", "np", ".", "inf", "]", "if", "isolation", ":", "grisolation", "=", "np", ".", "ma", ".", "masked_array", "(", "cumulative_costs", ",", "mask", "=", "np", ".", "logical_or", "(", "self", ".", "raster", ".", "mask", ",", "cumulative_costs", "==", "np", ".", "inf", ")", ",", "fill_value", "=", "np", ".", "nan", ")", ".", "mean", "(", ")", "/", "(", "7", "*", "24", ")", "start_points", ".", "loc", "[", "i", "[", "0", "]", ",", "'Iso'", "]", "=", "grisolation", "if", "export_raster", ":", "cumulative_costs", "=", "GeoRaster", "(", "np", ".", "ma", ".", "masked_array", "(", "cumulative_costs", ",", "mask", "=", "np", ".", "logical_or", "(", "self", ".", "raster", ".", "mask", ",", "cumulative_costs", "==", "np", ".", "inf", ")", ",", "fill_value", "=", "np", ".", "nan", ")", ",", "self", ".", "geot", ",", "self", ".", "nodata_value", ",", "projection", "=", "self", ".", "projection", ",", "datatype", "=", "self", ".", "datatype", ")", "cumulative_costs", ".", "raster", ".", "data", "[", "cumulative_costs", ".", "raster", ".", "mask", "]", "=", "cumulative_costs", ".", "nodata_value", "cumulative_costs", ".", "to_tiff", "(", "path", "+", "str", "(", "i", "[", "1", "]", "[", "'ID'", "]", ")", ")", "if", "df2", ".", "size", ">", "0", ":", "if", "export_shape", ":", "routes", "=", "True", "if", "routes", ":", "df2", "[", "'geometry'", "]", "=", "df2", "[", "'ID2'", "]", ".", "apply", "(", "lambda", "x", ":", "self", ".", "mcp_cost", ".", "traceback", "(", "end_points", ".", "loc", "[", "end_points", "[", "'ID'", "]", "==", "x", "]", "[", "[", "'row'", ",", "'col'", "]", "]", ".", "values", "[", "0", "]", ")", ")", "df2", "[", "'geometry'", "]", "=", "df2", ".", "geometry", ".", "apply", "(", "lambda", "x", ":", "[", "map_pixel_inv", "(", "y", "[", "0", "]", ",", "y", "[", "1", "]", ",", "self", ".", "geot", "[", "1", "]", ",", "self", ".", "geot", "[", "-", "1", "]", ",", "self", ".", "geot", "[", "0", "]", ",", "self", ".", "geot", "[", "-", "3", "]", ")", "for", "y", "in", "x", "]", ")", "df2", "[", "'geometry'", "]", "=", "df2", ".", "geometry", ".", "apply", "(", "lambda", "x", ":", "LineString", "(", "x", ")", "if", "int", "(", "len", "(", "x", ")", ">", "1", ")", "else", "LineString", "(", "[", "x", "[", "0", "]", ",", "x", "[", "0", "]", "]", ")", ")", "df2", "=", "gp", ".", "GeoDataFrame", "(", "df2", ",", "crs", "=", "cea", ")", "if", "isolation", ":", "df2", "[", "'Iso'", "]", "=", "grisolation", "if", "count", "==", "0", ":", "self", ".", "grdist", "=", "df2", ".", "copy", "(", ")", "else", ":", "self", ".", "grdist", "=", "self", ".", "grdist", ".", "append", "(", "df2", ")", "count", "+=", "1", "if", "routes", ":", "self", ".", "grdist", "=", "gp", ".", "GeoDataFrame", "(", "self", ".", "grdist", ",", "crs", "=", "cea", ")", "if", "export_shape", ":", "start_pointscols", "=", "sources", ".", "columns", ".", "values", "end_pointscols", "=", "destinations", ".", "columns", ".", "values", "if", "'geometry'", "in", "end_pointscols", ":", "self", ".", "grdist", "=", "pd", ".", "merge", "(", "self", ".", "grdist", ",", "end_points", "[", "[", "'ID'", "]", "+", "end_pointscols", ".", "tolist", "(", ")", "]", ".", "drop", "(", "'geometry'", ",", "axis", "=", "1", ")", ",", "left_on", "=", "'ID2'", ",", "right_on", "=", "'ID'", ",", "how", "=", "'left'", ")", "else", ":", "self", ".", "grdist", "=", "pd", ".", "merge", "(", "self", ".", "grdist", ",", "end_points", "[", "[", "'ID'", "]", "+", "end_pointscols", ".", "tolist", "(", ")", "]", ",", "left_on", "=", "'ID2'", ",", "right_on", "=", "'ID'", ",", "how", "=", "'left'", ")", "if", "'geometry'", "in", "self", ".", "start_pointscols", ":", "self", ".", "grdist", "=", "pd", ".", "merge", "(", "self", ".", "grdist", ",", "start_points", "[", "[", "'ID'", "]", "+", "start_pointscols", ".", "tolist", "(", ")", "]", ".", "drop", "(", "'geometry'", ",", "axis", "=", "1", ")", ",", "left_on", "=", "'ID1'", ",", "right_on", "=", "'ID'", ",", "how", "=", "'left'", ",", "suffixes", "=", "[", "'_2'", ",", "'_1'", "]", ")", "else", ":", "self", ".", "grdist", "=", "pd", ".", "merge", "(", "self", ".", "grdist", ",", "start_points", "[", "[", "'ID'", "]", "+", "start_pointscols", ".", "tolist", "(", ")", "]", ",", "left_on", "=", "'ID1'", ",", "right_on", "=", "'ID'", ",", "how", "=", "'left'", ",", "suffixes", "=", "[", "'_2'", ",", "'_1'", "]", ")", "self", ".", "grdist", "=", "gp", ".", "GeoDataFrame", "(", "self", ".", "grdist", ",", "crs", "=", "cea", ")", "self", ".", "grdist", ".", "to_file", "(", "path", "+", "'routes.shp'", ")" ]

[ "Compute", "cost", "distance", "measured", "from", "each", "start", "point", "to", "all", "end", "points", ".", "The", "function", "returns", "the", "distances", "between", "the", "start", "point", "and", "the", "end", "points", "as", "a", "Pandas", "dataframe", ".", "Additionally", "for", "each", "start", "point", "it", "computes", "the", "level", "of", "isolation", "i", ".", "e", ".", "its", "average", "travel", "distance", "to", "all", "other", "locations" ]

[ "def", "_init_map", "(", "self", ")", ":", "self", ".", "my_osid_object_form", ".", "_my_map", "[", "'zoneConditions'", "]", "=", "self", ".", "_zone_conditions_metadata", "[", "'default_object_values'", "]", "[", "0", "]", "self", ".", "my_osid_object_form", ".", "_my_map", "[", "'coordinateConditions'", "]", "=", "self", ".", "_coordinate_conditions_metadata", "[", "'default_object_values'", "]", "[", "0", "]", "self", ".", "my_osid_object_form", ".", "_my_map", "[", "'spatialUnitConditions'", "]", "=", "self", ".", "_spatial_unit_conditions_metadata", "[", "'default_object_values'", "]", "[", "0", "]" ]

[ "stub" ]

[ "def", "storagehandler", "(", "self", ")", ":", "if", "isinstance", "(", "self", ",", "StorageHandler", ")", ":", "return", "self", "elif", "self", ".", "parent", "is", "not", "None", ":", "return", "self", ".", "parent", ".", "storagehandler", "else", ":", "return", "None" ]

[ "Returns", "the", "storage", "handler", "available", "to", "thise", "actor", "." ]

[ "def", "remove_col_label", "(", "self", ",", "event", ")", ":", "#, include_pmag=True):", "er_possible_headers", "=", "self", ".", "grid_headers", "[", "self", ".", "grid_type", "]", "[", "'er'", "]", "[", "2", "]", "pmag_possible_headers", "=", "self", ".", "grid_headers", "[", "self", ".", "grid_type", "]", "[", "'pmag'", "]", "[", "2", "]", "er_actual_headers", "=", "self", ".", "grid_headers", "[", "self", ".", "grid_type", "]", "[", "'er'", "]", "[", "0", "]", "pmag_actual_headers", "=", "self", ".", "grid_headers", "[", "self", ".", "grid_type", "]", "[", "'pmag'", "]", "[", "0", "]", "col", "=", "event", ".", "GetCol", "(", ")", "label", "=", "self", ".", "grid", ".", "GetColLabelValue", "(", "col", ")", "if", "'**'", "in", "label", ":", "label", "=", "label", ".", "strip", "(", "'**'", ")", "if", "label", "in", "self", ".", "grid_headers", "[", "self", ".", "grid_type", "]", "[", "'er'", "]", "[", "1", "]", ":", "pw", ".", "simple_warning", "(", "\"That header is required, and cannot be removed\"", ")", "return", "False", "#elif include_pmag and label in self.grid_headers[self.grid_type]['pmag'][1]:", "# pw.simple_warning(\"That header is required, and cannot be removed\")", "# return False", "else", ":", "print", "(", "'That header is not required:'", ",", "label", ")", "self", ".", "grid", ".", "remove_col", "(", "col", ")", "#if label in er_possible_headers:", "try", ":", "print", "(", "'removing {} from er_actual_headers'", ".", "format", "(", "label", ")", ")", "er_actual_headers", ".", "remove", "(", "label", ")", "except", "ValueError", ":", "pass", "#if label in pmag_possible_headers:", "try", ":", "pmag_actual_headers", ".", "remove", "(", "label", ")", "except", "ValueError", ":", "pass", "# causes resize on each column header delete", "# can leave this out if we want.....", "self", ".", "main_sizer", ".", "Fit", "(", "self", ")" ]

[ "check", "to", "see", "if", "column", "is", "required", "if", "it", "is", "not", "delete", "it", "from", "grid" ]

[ "def", "make_path_writable", "(", "path", ")", ":", "from", "rez", ".", "config", "import", "config", "try", ":", "orig_mode", "=", "os", ".", "stat", "(", "path", ")", ".", "st_mode", "new_mode", "=", "orig_mode", "if", "config", ".", "make_package_temporarily_writable", "and", "not", "os", ".", "access", "(", "path", ",", "os", ".", "W_OK", ")", ":", "new_mode", "=", "orig_mode", "|", "stat", ".", "S_IWUSR", "# make writable", "if", "new_mode", "!=", "orig_mode", ":", "os", ".", "chmod", "(", "path", ",", "new_mode", ")", "except", "OSError", ":", "# ignore access errors here, and just do nothing. It will be more", "# intuitive for the calling code to fail on access instead.", "#", "orig_mode", "=", "None", "new_mode", "=", "None", "# yield, then reset mode back to original", "try", ":", "yield", "finally", ":", "if", "new_mode", "!=", "orig_mode", ":", "os", ".", "chmod", "(", "path", ",", "orig_mode", ")" ]

[ "Temporarily", "make", "path", "writable", "if", "possible", "." ]

[ "def", "commit", "(", "self", ",", "changeset_id", ":", "uuid", ".", "UUID", ")", "->", "None", ":", "self", ".", "_validate_changeset", "(", "changeset_id", ")", "journal_data", "=", "self", ".", "journal", ".", "commit_changeset", "(", "changeset_id", ")", "if", "self", ".", "journal", ".", "is_empty", "(", ")", ":", "# Ensure the journal automatically restarts recording after", "# it has been persisted to the underlying db", "self", ".", "reset", "(", ")", "for", "key", ",", "value", "in", "journal_data", ".", "items", "(", ")", ":", "try", ":", "if", "value", "is", "DELETED_ENTRY", ":", "del", "self", ".", "wrapped_db", "[", "key", "]", "elif", "value", "is", "ERASE_CREATED_ENTRY", ":", "pass", "else", ":", "self", ".", "wrapped_db", "[", "key", "]", "=", "cast", "(", "bytes", ",", "value", ")", "except", "Exception", ":", "self", ".", "_reapply_changeset_to_journal", "(", "changeset_id", ",", "journal_data", ")", "raise" ]

[ "Commits", "a", "given", "changeset", ".", "This", "merges", "the", "given", "changeset", "and", "all", "subsequent", "changesets", "into", "the", "previous", "changeset", "giving", "precidence", "to", "later", "changesets", "in", "case", "of", "any", "conflicting", "keys", "." ]

[ "def", "check_charset", "(", "self", ",", "ctx", ",", "char", ")", ":", "self", ".", "set_dispatcher", ".", "reset", "(", "char", ")", "save_position", "=", "ctx", ".", "code_position", "result", "=", "None", "while", "result", "is", "None", ":", "result", "=", "self", ".", "set_dispatcher", ".", "dispatch", "(", "ctx", ".", "peek_code", "(", ")", ",", "ctx", ")", "ctx", ".", "code_position", "=", "save_position", "return", "result" ]

[ "Checks", "whether", "a", "character", "matches", "set", "of", "arbitrary", "length", ".", "Assumes", "the", "code", "pointer", "is", "at", "the", "first", "member", "of", "the", "set", "." ]

[ "def", "step_impl09", "(", "context", ")", ":", "assert", "context", ".", "table", ",", "\"ENSURE: table is provided.\"", "context", ".", "app_list", "=", "[", "row", "[", "'application'", "]", "for", "row", "in", "context", ".", "table", ".", "rows", "]" ]

[ "Create", "application", "list", "." ]

[ "def", "idngram2lm", "(", "idngram_file", ",", "vocab_file", ",", "output_file", ",", "context_file", "=", "None", ",", "vocab_type", "=", "1", ",", "oov_fraction", "=", "0.5", ",", "four_byte_counts", "=", "False", ",", "min_unicount", "=", "0", ",", "zeroton_fraction", "=", "False", ",", "n", "=", "3", ",", "verbosity", "=", "2", ",", "arpa_output", "=", "True", ",", "ascii_input", "=", "False", ")", ":", "# TODO: Args still missing", "# [ -calc_mem | -buffer 100 | -spec_num y ... z ]", "# [ -two_byte_bo_weights ", "# [ -min_bo_weight nnnnn] [ -max_bo_weight nnnnn] [ -out_of_range_bo_weights] ]", "# [ -linear | -absolute | -good_turing | -witten_bell ]", "# [ -disc_ranges 1 7 7 ]", "# [ -cutoffs 0 ... 0 ]", "cmd", "=", "[", "'idngram2lm'", ",", "'-idngram'", ",", "os", ".", "path", ".", "abspath", "(", "idngram_file", ")", ",", "'-vocab'", ",", "os", ".", "path", ".", "abspath", "(", "vocab_file", ")", ",", "'-vocab_type'", ",", "vocab_type", ",", "'-oov_fraction'", ",", "oov_fraction", ",", "'-min_unicount'", ",", "min_unicount", ",", "'-verbosity'", ",", "verbosity", ",", "'-n'", ",", "n", "]", "if", "arpa_output", ":", "cmd", ".", "extend", "(", "[", "'-arpa'", ",", "output_file", "]", ")", "else", ":", "cmd", ".", "extend", "(", "[", "'-binary'", ",", "output_file", "]", ")", "if", "four_byte_counts", ":", "cmd", ".", "append", "(", "'-four_byte_counts'", ")", "if", "zeroton_fraction", ":", "cmd", ".", "append", "(", "'-zeroton_fraction'", ")", "if", "ascii_input", ":", "cmd", ".", "append", "(", "'-ascii_input'", ")", "else", ":", "cmd", ".", "append", "(", "'-bin_input'", ")", "# Ensure that every parameter is of type 'str'", "cmd", "=", "[", "str", "(", "x", ")", "for", "x", "in", "cmd", "]", "with", "tempfile", ".", "SpooledTemporaryFile", "(", ")", "as", "output_f", ":", "with", "output_to_debuglogger", "(", ")", "as", "err_f", ":", "exitcode", "=", "subprocess", ".", "call", "(", "cmd", ",", "stdout", "=", "output_f", ",", "stderr", "=", "err_f", ")", "output", "=", "output_f", ".", "read", "(", ")", "logger", "=", "logging", ".", "getLogger", "(", "__name__", ")", "logger", ".", "debug", "(", "\"Command '%s' returned with exit code '%d'.\"", "%", "(", "' '", ".", "join", "(", "cmd", ")", ",", "exitcode", ")", ")", "if", "exitcode", "!=", "0", ":", "raise", "ConversionError", "(", "\"'%s' returned with non-zero exit status '%s'\"", "%", "(", "cmd", "[", "0", "]", ",", "exitcode", ")", ")", "if", "sys", ".", "version_info", ">=", "(", "3", ",", ")", "and", "type", "(", "output", ")", "is", "bytes", ":", "output", "=", "output", ".", "decode", "(", "'utf-8'", ")", "return", "output", ".", "strip", "(", ")" ]

[ "Takes", "an", "idngram", "-", "file", "(", "in", "either", "binary", "(", "by", "default", ")", "or", "ASCII", "(", "if", "specified", ")", "format", ")", "a", "vocabulary", "file", "and", "(", "optionally", ")", "a", "context", "cues", "file", ".", "Additional", "command", "line", "parameters", "will", "specify", "the", "cutoffs", "the", "discounting", "strategy", "and", "parameters", "etc", ".", "It", "outputs", "a", "language", "model", "in", "either", "binary", "format", "(", "to", "be", "read", "by", "evallm", ")", "or", "in", "ARPA", "format", "." ]

[ "def", "ed25519_private_key_to_string", "(", "key", ")", ":", "return", "base64", ".", "b64encode", "(", "key", ".", "private_bytes", "(", "encoding", "=", "serialization", ".", "Encoding", ".", "Raw", ",", "format", "=", "serialization", ".", "PrivateFormat", ".", "Raw", ",", "encryption_algorithm", "=", "serialization", ".", "NoEncryption", "(", ")", ")", ",", "None", ")", ".", "decode", "(", "'utf-8'", ")" ]

[ "Convert", "an", "ed25519", "private", "key", "to", "a", "base64", "-", "encoded", "string", "." ]

[ "def", "_set_tunnel_dst", "(", "self", ",", "v", ",", "load", "=", "False", ")", ":", "if", "hasattr", "(", "v", ",", "\"_utype\"", ")", ":", "v", "=", "v", ".", "_utype", "(", "v", ")", "try", ":", "t", "=", "YANGDynClass", "(", "v", ",", "base", "=", "YANGListType", "(", "\"address\"", ",", "tunnel_dst", ".", "tunnel_dst", ",", "yang_name", "=", "\"tunnel-dst\"", ",", "rest_name", "=", "\"ip\"", ",", "parent", "=", "self", ",", "is_container", "=", "'list'", ",", "user_ordered", "=", "False", ",", "path_helper", "=", "self", ".", "_path_helper", ",", "yang_keys", "=", "'address'", ",", "extensions", "=", "{", "u'tailf-common'", ":", "{", "u'info'", ":", "u'IP configuration for site.'", ",", "u'cli-suppress-mode'", ":", "None", ",", "u'cli-compact-syntax'", ":", "None", ",", "u'alt-name'", ":", "u'ip'", ",", "u'callpoint'", ":", "u'overlay-site-ip-cp'", "}", "}", ")", ",", "is_container", "=", "'list'", ",", "yang_name", "=", "\"tunnel-dst\"", ",", "rest_name", "=", "\"ip\"", ",", "parent", "=", "self", ",", "path_helper", "=", "self", ".", "_path_helper", ",", "extmethods", "=", "self", ".", "_extmethods", ",", "register_paths", "=", "True", ",", "extensions", "=", "{", "u'tailf-common'", ":", "{", "u'info'", ":", "u'IP configuration for site.'", ",", "u'cli-suppress-mode'", ":", "None", ",", "u'cli-compact-syntax'", ":", "None", ",", "u'alt-name'", ":", "u'ip'", ",", "u'callpoint'", ":", "u'overlay-site-ip-cp'", "}", "}", ",", "namespace", "=", "'urn:brocade.com:mgmt:brocade-tunnels'", ",", "defining_module", "=", "'brocade-tunnels'", ",", "yang_type", "=", "'list'", ",", "is_config", "=", "True", ")", "except", "(", "TypeError", ",", "ValueError", ")", ":", "raise", "ValueError", "(", "{", "'error-string'", ":", "\"\"\"tunnel_dst must be of a type compatible with list\"\"\"", ",", "'defined-type'", ":", "\"list\"", ",", "'generated-type'", ":", "\"\"\"YANGDynClass(base=YANGListType(\"address\",tunnel_dst.tunnel_dst, yang_name=\"tunnel-dst\", rest_name=\"ip\", parent=self, is_container='list', user_ordered=False, path_helper=self._path_helper, yang_keys='address', extensions={u'tailf-common': {u'info': u'IP configuration for site.', u'cli-suppress-mode': None, u'cli-compact-syntax': None, u'alt-name': u'ip', u'callpoint': u'overlay-site-ip-cp'}}), is_container='list', yang_name=\"tunnel-dst\", rest_name=\"ip\", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'tailf-common': {u'info': u'IP configuration for site.', u'cli-suppress-mode': None, u'cli-compact-syntax': None, u'alt-name': u'ip', u'callpoint': u'overlay-site-ip-cp'}}, namespace='urn:brocade.com:mgmt:brocade-tunnels', defining_module='brocade-tunnels', yang_type='list', is_config=True)\"\"\"", ",", "}", ")", "self", ".", "__tunnel_dst", "=", "t", "if", "hasattr", "(", "self", ",", "'_set'", ")", ":", "self", ".", "_set", "(", ")" ]

[ "Setter", "method", "for", "tunnel_dst", "mapped", "from", "YANG", "variable", "/", "overlay_gateway", "/", "site", "/", "tunnel_dst", "(", "list", ")", "If", "this", "variable", "is", "read", "-", "only", "(", "config", ":", "false", ")", "in", "the", "source", "YANG", "file", "then", "_set_tunnel_dst", "is", "considered", "as", "a", "private", "method", ".", "Backends", "looking", "to", "populate", "this", "variable", "should", "do", "so", "via", "calling", "thisObj", ".", "_set_tunnel_dst", "()", "directly", "." ]

[ "def", "position_with_ref", "(", "msg", ",", "lat_ref", ",", "lon_ref", ")", ":", "tc", "=", "typecode", "(", "msg", ")", "if", "5", "<=", "tc", "<=", "8", ":", "return", "surface_position_with_ref", "(", "msg", ",", "lat_ref", ",", "lon_ref", ")", "elif", "9", "<=", "tc", "<=", "18", "or", "20", "<=", "tc", "<=", "22", ":", "return", "airborne_position_with_ref", "(", "msg", ",", "lat_ref", ",", "lon_ref", ")", "else", ":", "raise", "RuntimeError", "(", "\"incorrect or inconsistant message types\"", ")" ]

[ "Decode", "position", "with", "only", "one", "message", "knowing", "reference", "nearby", "location", "such", "as", "previously", "calculated", "location", "ground", "station", "or", "airport", "location", "etc", ".", "Works", "with", "both", "airborne", "and", "surface", "position", "messages", ".", "The", "reference", "position", "shall", "be", "with", "in", "180NM", "(", "airborne", ")", "or", "45NM", "(", "surface", ")", "of", "the", "true", "position", "." ]

[ "def", "_sampleFromFaces", "(", "self", ")", ":", "coordinates", "=", "[", "random", ".", "uniform", "(", "-", "1", ",", "1", ")", "*", "dim", "/", "2.", "for", "dim", "in", "self", ".", "dimensions", "]", "dim", "=", "random", ".", "choice", "(", "range", "(", "self", ".", "dimension", ")", ")", "coordinates", "[", "dim", "]", "=", "self", ".", "dimensions", "[", "dim", "]", "/", "2.", "*", "random", ".", "choice", "(", "[", "-", "1", ",", "1", "]", ")", "return", "coordinates" ]

[ "We", "start", "by", "sampling", "a", "dimension", "to", "max", "out", "then", "sample", "the", "sign", "and", "the", "other", "dimensions", "values", "." ]

[ "def", "shutdown_host", "(", "kwargs", "=", "None", ",", "call", "=", "None", ")", ":", "if", "call", "!=", "'function'", ":", "raise", "SaltCloudSystemExit", "(", "'The shutdown_host function must be called with '", "'-f or --function.'", ")", "host_name", "=", "kwargs", ".", "get", "(", "'host'", ")", "if", "kwargs", "and", "'host'", "in", "kwargs", "else", "None", "force", "=", "_str_to_bool", "(", "kwargs", ".", "get", "(", "'force'", ")", ")", "if", "kwargs", "and", "'force'", "in", "kwargs", "else", "False", "if", "not", "host_name", ":", "raise", "SaltCloudSystemExit", "(", "'You must specify name of the host system.'", ")", "# Get the service instance", "si", "=", "_get_si", "(", ")", "host_ref", "=", "salt", ".", "utils", ".", "vmware", ".", "get_mor_by_property", "(", "si", ",", "vim", ".", "HostSystem", ",", "host_name", ")", "if", "not", "host_ref", ":", "raise", "SaltCloudSystemExit", "(", "'Specified host system does not exist.'", ")", "if", "host_ref", ".", "runtime", ".", "connectionState", "==", "'notResponding'", ":", "raise", "SaltCloudSystemExit", "(", "'Specified host system cannot be shut down in it\\'s current state (not responding).'", ")", "if", "not", "host_ref", ".", "capability", ".", "rebootSupported", ":", "raise", "SaltCloudSystemExit", "(", "'Specified host system does not support shutdown.'", ")", "if", "not", "host_ref", ".", "runtime", ".", "inMaintenanceMode", "and", "not", "force", ":", "raise", "SaltCloudSystemExit", "(", "'Specified host system is not in maintenance mode. Specify force=True to '", "'force reboot even if there are virtual machines running or other operations '", "'in progress.'", ")", "try", ":", "host_ref", ".", "ShutdownHost_Task", "(", "force", ")", "except", "Exception", "as", "exc", ":", "log", ".", "error", "(", "'Error while shutting down host %s: %s'", ",", "host_name", ",", "exc", ",", "# Show the traceback if the debug logging level is enabled", "exc_info_on_loglevel", "=", "logging", ".", "DEBUG", ")", "return", "{", "host_name", ":", "'failed to shut down host'", "}", "return", "{", "host_name", ":", "'shut down host'", "}" ]

[ "Shut", "down", "the", "specified", "host", "system", "in", "this", "VMware", "environment" ]

[ "def", "get_plot", "(", "self_or_cls", ",", "obj", ",", "doc", "=", "None", ",", "renderer", "=", "None", ",", "*", "*", "kwargs", ")", ":", "if", "doc", "is", "None", ":", "doc", "=", "Document", "(", ")", "if", "self_or_cls", ".", "notebook_context", "else", "curdoc", "(", ")", "if", "self_or_cls", ".", "notebook_context", ":", "curdoc", "(", ")", ".", "theme", "=", "self_or_cls", ".", "theme", "doc", ".", "theme", "=", "self_or_cls", ".", "theme", "plot", "=", "super", "(", "BokehRenderer", ",", "self_or_cls", ")", ".", "get_plot", "(", "obj", ",", "renderer", ",", "*", "*", "kwargs", ")", "plot", ".", "document", "=", "doc", "return", "plot" ]

[ "Given", "a", "HoloViews", "Viewable", "return", "a", "corresponding", "plot", "instance", ".", "Allows", "supplying", "a", "document", "attach", "the", "plot", "to", "useful", "when", "combining", "the", "bokeh", "model", "with", "another", "plot", "." ]

[ "def", "intercept_image_formats", "(", "self", ",", "options", ")", ":", "if", "'entityTypes'", "in", "options", ":", "for", "entity", "in", "options", "[", "'entityTypes'", "]", ":", "if", "entity", "[", "'type'", "]", "==", "ENTITY_TYPES", ".", "IMAGE", "and", "'imageFormats'", "in", "entity", ":", "if", "entity", "[", "'imageFormats'", "]", "==", "'__all__'", ":", "entity", "[", "'imageFormats'", "]", "=", "get_all_image_formats", "(", ")", "return", "options" ]

[ "Load", "all", "image", "formats", "if", "needed", "." ]

[ "def", "git_tag_to_semver", "(", "git_tag", ":", "str", ")", "->", "SemVer", ":", "pattern", "=", "re", ".", "compile", "(", "r'[0-9]+\\.[0-9]+\\.[0-9]+$'", ")", "match", "=", "pattern", ".", "search", "(", "git_tag", ")", "if", "match", ":", "version", "=", "match", ".", "group", "(", "0", ")", "else", ":", "raise", "InvalidTagFormatException", "(", "'Tag passed contains no SemVer.'", ")", "return", "SemVer", ".", "from_str", "(", "version", ")" ]

[ ":", "git_tag", ":", "A", "string", "representation", "of", "a", "Git", "tag", "." ]

[ "def", "_lemmatise_contractions", "(", "self", ",", "f", ",", "*", "args", ",", "*", "*", "kwargs", ")", ":", "fd", "=", "f", "for", "contraction", ",", "decontraction", "in", "self", ".", "_contractions", ".", "items", "(", ")", ":", "if", "fd", ".", "endswith", "(", "contraction", ")", ":", "fd", "=", "f", "[", ":", "-", "len", "(", "contraction", ")", "]", "if", "\"v\"", "in", "fd", "or", "\"V\"", "in", "fd", ":", "fd", "+=", "decontraction", "else", ":", "fd", "+=", "deramise", "(", "decontraction", ")", "yield", "from", "self", ".", "_lemmatise", "(", "fd", ",", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "Lemmatise", "un", "mot", "f", "avec", "sa", "contraction" ]

[ "def", "write", "(", "self", ",", "filename", "=", "None", ")", ":", "if", "not", "filename", ":", "filename", "=", "self", ".", "filename", "# update time", "self", ".", "properties", ".", "CurrentDate", "=", "_current_time", "(", ")", "# set rubber band to true", "self", ".", "properties", ".", "EnableRubberBand", "=", "'true'", "# update start position", "self", ".", "update_start_position", "(", ")", "# update well postions", "self", ".", "update_well_positions", "(", ")", "# update counts", "self", ".", "update_counts", "(", ")", "# remove py:pytype attributes", "objectify", ".", "deannotate", "(", "self", ".", "root", ")", "# remove namespaces added by lxml", "for", "child", "in", "self", ".", "root", ".", "iterchildren", "(", ")", ":", "etree", ".", "cleanup_namespaces", "(", "child", ")", "xml", "=", "etree", ".", "tostring", "(", "self", ".", "root", ",", "encoding", "=", "'utf8'", ",", "xml_declaration", "=", "True", ",", "pretty_print", "=", "True", ")", "# fix format quirks", "# add carriage return character", "xml", "=", "u'\\r\\n'", ".", "join", "(", "l", ".", "decode", "(", "encoding", "=", "'utf8'", ")", "for", "l", "in", "xml", ".", "splitlines", "(", ")", ")", "# add space at \"end/>\" --> \"end />\"", "xml", "=", "re", ".", "sub", "(", "r'([\"a-z])/>'", ",", "r'\\1 />'", ",", "xml", ")", "xml", "=", "xml", ".", "replace", "(", "\"version='1.0' encoding='utf8'\"", ",", "'version=\"1.0\"'", ")", "with", "open", "(", "filename", ",", "'wb'", ")", "as", "f", ":", "f", ".", "write", "(", "xml", ".", "encode", "(", "'utf8'", ")", ")" ]

[ "Save", "template", "to", "xml", ".", "Before", "saving", "template", "will", "update", "date", "start", "position", "well", "positions", "and", "counts", "." ]

[ "def", "interpolate_single", "(", "start", ",", "end", ",", "coefficient", ",", "how", "=", "'linear'", ")", ":", "return", "INTERP_SINGLE_DICT", "[", "how", "]", "(", "start", ",", "end", ",", "coefficient", ")" ]

[ "Interpolate", "single", "value", "between", "start", "and", "end", "in", "given", "number", "of", "steps" ]

[ "def", "batch_fun", "(", "dataset", ",", "training", ",", "shapes", ",", "target_names", ",", "num_devices", ",", "batch_size_per_device", "=", "32", ",", "batch_size", "=", "None", ",", "eval_batch_size", "=", "32", ",", "bucket_length", "=", "32", ",", "buckets", "=", "None", ",", "batch_shuffle_size", "=", "128", ",", "max_eval_length", "=", "None", ")", ":", "del", "target_names", "# Batch size is batch_size_per_device * num_devices unless given directly.", "batch_size", "=", "batch_size", "or", "batch_size_per_device", "*", "num_devices", "# If bucketing is not specified, check if target shapes are variable.", "cur_batch_size", "=", "batch_size", "if", "training", "else", "eval_batch_size", "# Make cur_batch_size divisible by num_devices.", "cur_batch_size", "=", "max", "(", "cur_batch_size", "//", "num_devices", ",", "1", ")", "*", "num_devices", "# Create heuristic buckets is none are specified.", "if", "buckets", "is", "None", ":", "variable_target_shapes", "=", "False", "target_shape", "=", "shapes", "[", "1", "]", "for", "dim", "in", "target_shape", ":", "if", "dim", "is", "None", ":", "variable_target_shapes", "=", "True", "tf", ".", "logging", ".", "info", "(", "\"Heuristically setting bucketing to %s based on shapes \"", "\"of target tensors.\"", "%", "variable_target_shapes", ")", "if", "variable_target_shapes", ":", "bucket_boundaries", "=", "[", "bucket_length", "//", "4", ",", "bucket_length", "//", "2", ",", "bucket_length", ",", "bucket_length", "*", "2", ",", "bucket_length", "*", "4", ",", "bucket_length", "*", "8", ",", "bucket_length", "*", "16", "]", "# We will pad to boundaries which pads to bucket_boundary - 1: add 1 here.", "bucket_boundaries", "=", "[", "b", "+", "1", "for", "b", "in", "bucket_boundaries", "]", "if", "not", "training", ":", "max_eval_length", "=", "max_eval_length", "or", "bucket_length", "*", "32", "bucket_boundaries", "[", "-", "1", "]", "=", "max_eval_length", "bucket_batch_sizes", "=", "[", "cur_batch_size", "*", "4", ",", "cur_batch_size", "*", "2", ",", "cur_batch_size", ",", "cur_batch_size", "//", "2", ",", "cur_batch_size", "//", "4", ",", "cur_batch_size", "//", "8", ",", "cur_batch_size", "//", "16", ",", "1", "]", "if", "not", "training", ":", "bucket_batch_sizes", "[", "-", "2", "]", "=", "cur_batch_size", "//", "max_eval_length", "# Make batch sizes divisible by num_devices.", "bucket_batch_sizes", "=", "[", "max", "(", "b", "//", "num_devices", ",", "1", ")", "*", "num_devices", "for", "b", "in", "bucket_batch_sizes", "]", "buckets", "=", "(", "bucket_boundaries", ",", "bucket_batch_sizes", ")", "if", "buckets", ":", "tf", ".", "logging", ".", "info", "(", "\"Bucketing with buckets %s.\"", "%", "str", "(", "buckets", ")", ")", "def", "example_length", "(", "_", ",", "target", ")", ":", "return", "tf", ".", "shape", "(", "target", ")", "[", "0", "]", "boundaries", ",", "batch_sizes", "=", "buckets", "dataset", "=", "dataset", ".", "apply", "(", "tf", ".", "data", ".", "experimental", ".", "bucket_by_sequence_length", "(", "example_length", ",", "boundaries", ",", "batch_sizes", ",", "pad_to_bucket_boundary", "=", "True", ")", ")", "else", ":", "dataset", "=", "dataset", ".", "padded_batch", "(", "cur_batch_size", ",", "shapes", ")", "if", "training", ":", "return", "dataset", ".", "shuffle", "(", "batch_shuffle_size", ")", "return", "dataset" ]

[ "Batching", "function", "." ]

[ "def", "get_auto_correlation_time", "(", "chain", ",", "max_lag", "=", "None", ")", ":", "max_lag", "=", "max_lag", "or", "min", "(", "len", "(", "chain", ")", "//", "3", ",", "1000", ")", "normalized_chain", "=", "chain", "-", "np", ".", "mean", "(", "chain", ",", "dtype", "=", "np", ".", "float64", ")", "previous_accoeff", "=", "0", "auto_corr_sum", "=", "0", "for", "lag", "in", "range", "(", "1", ",", "max_lag", ")", ":", "auto_correlation_coeff", "=", "np", ".", "mean", "(", "normalized_chain", "[", ":", "len", "(", "chain", ")", "-", "lag", "]", "*", "normalized_chain", "[", "lag", ":", "]", ",", "dtype", "=", "np", ".", "float64", ")", "if", "lag", "%", "2", "==", "0", ":", "if", "previous_accoeff", "+", "auto_correlation_coeff", "<=", "0", ":", "break", "auto_corr_sum", "+=", "auto_correlation_coeff", "previous_accoeff", "=", "auto_correlation_coeff", "return", "auto_corr_sum", "/", "np", ".", "var", "(", "chain", ",", "dtype", "=", "np", ".", "float64", ")" ]

[ "r", "Compute", "the", "auto", "correlation", "time", "up", "to", "the", "given", "lag", "for", "the", "given", "chain", "(", "1d", "vector", ")", "." ]

[ "def", "save", "(", "self", ",", "*", "args", ",", "*", "*", "kwargs", ")", ":", "self", ".", "name", "=", "str", "(", "self", ".", "parent", ".", "name", ")", "+", "\" - \"", "+", "str", "(", "self", ".", "child", ".", "name", ")", "+", "\" - \"", "+", "str", "(", "self", ".", "ownership_type", ")", "if", "self", ".", "amount", ">", "100", ":", "raise", "ValueError", "(", "\"Ownership amount cannot be more than 100%\"", ")", "elif", "self", ".", "amount", "<", "0", ":", "raise", "ValueError", "(", "\"Ownership amount cannot be less than 0%\"", ")", "else", ":", "super", "(", "Ownership", ",", "self", ")", ".", "save", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "Generate", "a", "name", "and", "ensure", "amount", "is", "less", "than", "or", "equal", "to", "100" ]

[ "def", "_update_subinstance", "(", "self", ",", "name", ",", "subform", ")", ":", "old_subinstance", "=", "getattr", "(", "self", ".", "instance", ",", "name", ")", "new_subinstance", "=", "subform", ".", "update_instance", "(", ")", "# if our instance previously had no node for the subform AND the", "# updated one has data, then attach the new node.", "if", "old_subinstance", "is", "None", "and", "not", "new_subinstance", ".", "is_empty", "(", ")", ":", "setattr", "(", "self", ".", "instance", ",", "name", ",", "new_subinstance", ")", "# on the other hand, if the instance previously had a node for the", "# subform AND the updated one is empty, then remove the node.", "if", "old_subinstance", "is", "not", "None", "and", "new_subinstance", ".", "is_empty", "(", ")", ":", "delattr", "(", "self", ".", "instance", ",", "name", ")" ]

[ "Save", "bound", "data", "for", "a", "single", "subform", "into", "the", "XmlObject", "model", "instance", "." ]

[ "def", "reraise", "(", "clazz", ")", ":", "def", "_decorator", "(", "f", ")", ":", "@", "functools", ".", "wraps", "(", "f", ")", "def", "_wrap", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "try", ":", "return", "f", "(", "*", "args", ",", "*", "*", "kwargs", ")", "except", "Exception", "as", "e", ":", "raise", "clazz", "(", "e", ")", ",", "None", ",", "sys", ".", "exc_info", "(", ")", "[", "2", "]", "return", "_wrap", "return", "_decorator" ]

[ "Decorator", "catching", "every", "exception", "that", "might", "be", "raised", "by", "wrapped", "function", "and", "raise", "another", "exception", "instead", ".", "Exception", "initially", "raised", "is", "passed", "in", "first", "argument", "of", "the", "raised", "exception", "." ]

[ "def", "sdram_alloc_as_filelike", "(", "self", ",", "size", ",", "tag", "=", "0", ",", "x", "=", "Required", ",", "y", "=", "Required", ",", "app_id", "=", "Required", ",", "clear", "=", "False", ")", ":", "# Perform the malloc", "start_address", "=", "self", ".", "sdram_alloc", "(", "size", ",", "tag", ",", "x", ",", "y", ",", "app_id", ",", "clear", ")", "return", "MemoryIO", "(", "self", ",", "x", ",", "y", ",", "start_address", ",", "start_address", "+", "size", ")" ]

[ "Like", ":", "py", ":", "meth", ":", ".", "sdram_alloc", "but", "returns", "a", ":", "py", ":", "class", ":", "file", "-", "like", "object", "<", ".", "MemoryIO", ">", "which", "allows", "safe", "reading", "and", "writing", "to", "the", "block", "that", "is", "allocated", "." ]

[ "def", "compute_edges", "(", "self", ",", "rules", ":", "List", "[", "str", "]", "=", "None", ",", "ast_result", "=", "False", ",", "fmt", "=", "\"medium\"", ")", "->", "List", "[", "Mapping", "[", "str", ",", "Any", "]", "]", ":", "if", "not", "self", ".", "ast", ":", "return", "self", "edges_asts", "=", "bel", ".", "edge", ".", "computed", ".", "compute_edges", "(", "self", ".", "ast", ",", "self", ".", "spec", ")", "if", "ast_result", ":", "return", "edges_asts", "edges", "=", "[", "]", "for", "ast", "in", "edges_asts", ":", "edges", ".", "append", "(", "{", "\"subject\"", ":", "ast", ".", "bel_subject", ".", "to_string", "(", ")", ",", "\"relation\"", ":", "ast", ".", "bel_relation", ",", "\"object\"", ":", "ast", ".", "bel_object", ".", "to_string", "(", ")", ",", "}", ")", "return", "edges" ]

[ "Computed", "edges", "from", "primary", "BEL", "statement" ]

[ "def", "list_devices", "(", ")", ":", "devices", "=", "[", "]", "all_hids", "=", "hid", ".", "find_all_hid_devices", "(", ")", "if", "all_hids", ":", "for", "index", ",", "device", "in", "enumerate", "(", "all_hids", ")", ":", "for", "device_name", ",", "spec", "in", "device_specs", ".", "items", "(", ")", ":", "if", "device", ".", "vendor_id", "==", "spec", ".", "hid_id", "[", "0", "]", "and", "device", ".", "product_id", "==", "spec", ".", "hid_id", "[", "1", "]", ":", "devices", ".", "append", "(", "device_name", ")", "return", "devices" ]

[ "Return", "a", "list", "of", "the", "supported", "devices", "connected", "Returns", ":", "A", "list", "of", "string", "names", "of", "the", "devices", "supported", "which", "were", "found", ".", "Empty", "if", "no", "supported", "devices", "found" ]

[ "def", "count_states", "(", "dtrajs", ",", "ignore_negative", "=", "False", ")", ":", "# format input", "dtrajs", "=", "_ensure_dtraj_list", "(", "dtrajs", ")", "# make bincounts for each input trajectory", "nmax", "=", "0", "bcs", "=", "[", "]", "for", "dtraj", "in", "dtrajs", ":", "if", "ignore_negative", ":", "dtraj", "=", "dtraj", "[", "np", ".", "where", "(", "dtraj", ">=", "0", ")", "]", "bc", "=", "np", ".", "bincount", "(", "dtraj", ")", "nmax", "=", "max", "(", "nmax", ",", "bc", ".", "shape", "[", "0", "]", ")", "bcs", ".", "append", "(", "bc", ")", "# construct total bincount", "res", "=", "np", ".", "zeros", "(", "nmax", ",", "dtype", "=", "int", ")", "# add up individual bincounts", "for", "i", ",", "bc", "in", "enumerate", "(", "bcs", ")", ":", "res", "[", ":", "bc", ".", "shape", "[", "0", "]", "]", "+=", "bc", "return", "res" ]

[ "r", "returns", "a", "histogram", "count" ]

[ "def", "get_location_observation", "(", "lat", ",", "lng", ",", "token", ")", ":", "req", "=", "requests", ".", "get", "(", "API_ENDPOINT_GEO", "%", "(", "lat", ",", "lng", ")", ",", "params", "=", "{", "'token'", ":", "token", "}", ")", "if", "req", ".", "status_code", "==", "200", "and", "req", ".", "json", "(", ")", "[", "\"status\"", "]", "==", "\"ok\"", ":", "return", "parse_observation_response", "(", "req", ".", "json", "(", ")", "[", "\"data\"", "]", ")", "return", "{", "}" ]

[ "Lookup", "observations", "by", "geo", "coordinates", "." ]

[ "def", "is_daylight_saving_hour", "(", "self", ",", "datetime", ")", ":", "if", "not", "self", ".", "daylight_saving_period", ":", "return", "False", "return", "self", ".", "daylight_saving_period", ".", "isTimeIncluded", "(", "datetime", ".", "hoy", ")" ]

[ "Check", "if", "a", "datetime", "is", "a", "daylight", "saving", "time", "." ]

[ "def", "__resolve_namespaced_symbol", "(", "# pylint: disable=too-many-branches", "ctx", ":", "ParserContext", ",", "form", ":", "sym", ".", "Symbol", ")", "->", "Union", "[", "MaybeClass", ",", "MaybeHostForm", ",", "VarRef", "]", ":", "assert", "form", ".", "ns", "is", "not", "None", "if", "form", ".", "ns", "==", "ctx", ".", "current_ns", ".", "name", ":", "v", "=", "ctx", ".", "current_ns", ".", "find", "(", "sym", ".", "symbol", "(", "form", ".", "name", ")", ")", "if", "v", "is", "not", "None", ":", "return", "VarRef", "(", "form", "=", "form", ",", "var", "=", "v", ",", "env", "=", "ctx", ".", "get_node_env", "(", ")", ")", "elif", "form", ".", "ns", "==", "_BUILTINS_NS", ":", "class_", "=", "munge", "(", "form", ".", "name", ",", "allow_builtins", "=", "True", ")", "target", "=", "getattr", "(", "builtins", ",", "class_", ",", "None", ")", "if", "target", "is", "None", ":", "raise", "ParserException", "(", "f\"cannot resolve builtin function '{class_}'\"", ",", "form", "=", "form", ")", "return", "MaybeClass", "(", "form", "=", "form", ",", "class_", "=", "class_", ",", "target", "=", "target", ",", "env", "=", "ctx", ".", "get_node_env", "(", ")", ")", "if", "\".\"", "in", "form", ".", "name", ":", "raise", "ParserException", "(", "\"symbol names may not contain the '.' operator\"", ",", "form", "=", "form", ")", "ns_sym", "=", "sym", ".", "symbol", "(", "form", ".", "ns", ")", "if", "ns_sym", "in", "ctx", ".", "current_ns", ".", "imports", "or", "ns_sym", "in", "ctx", ".", "current_ns", ".", "import_aliases", ":", "# We still import Basilisp code, so we'll want to make sure", "# that the symbol isn't referring to a Basilisp Var first", "v", "=", "Var", ".", "find", "(", "form", ")", "if", "v", "is", "not", "None", ":", "return", "VarRef", "(", "form", "=", "form", ",", "var", "=", "v", ",", "env", "=", "ctx", ".", "get_node_env", "(", ")", ")", "# Fetch the full namespace name for the aliased namespace/module.", "# We don't need this for actually generating the link later, but", "# we _do_ need it for fetching a reference to the module to check", "# for membership.", "if", "ns_sym", "in", "ctx", ".", "current_ns", ".", "import_aliases", ":", "ns", "=", "ctx", ".", "current_ns", ".", "import_aliases", "[", "ns_sym", "]", "assert", "ns", "is", "not", "None", "ns_name", "=", "ns", ".", "name", "else", ":", "ns_name", "=", "ns_sym", ".", "name", "safe_module_name", "=", "munge", "(", "ns_name", ")", "assert", "(", "safe_module_name", "in", "sys", ".", "modules", ")", ",", "f\"Module '{safe_module_name}' is not imported\"", "ns_module", "=", "sys", ".", "modules", "[", "safe_module_name", "]", "safe_name", "=", "munge", "(", "form", ".", "name", ")", "# Try without allowing builtins first", "if", "safe_name", "in", "vars", "(", "ns_module", ")", ":", "return", "MaybeHostForm", "(", "form", "=", "form", ",", "class_", "=", "munge", "(", "ns_sym", ".", "name", ")", ",", "field", "=", "safe_name", ",", "target", "=", "vars", "(", "ns_module", ")", "[", "safe_name", "]", ",", "env", "=", "ctx", ".", "get_node_env", "(", ")", ",", ")", "# Then allow builtins", "safe_name", "=", "munge", "(", "form", ".", "name", ",", "allow_builtins", "=", "True", ")", "if", "safe_name", "not", "in", "vars", "(", "ns_module", ")", ":", "raise", "ParserException", "(", "\"can't identify aliased form\"", ",", "form", "=", "form", ")", "# Aliased imports generate code which uses the import alias, so we", "# don't need to care if this is an import or an alias.", "return", "MaybeHostForm", "(", "form", "=", "form", ",", "class_", "=", "munge", "(", "ns_sym", ".", "name", ")", ",", "field", "=", "safe_name", ",", "target", "=", "vars", "(", "ns_module", ")", "[", "safe_name", "]", ",", "env", "=", "ctx", ".", "get_node_env", "(", ")", ",", ")", "elif", "ns_sym", "in", "ctx", ".", "current_ns", ".", "aliases", ":", "aliased_ns", ":", "runtime", ".", "Namespace", "=", "ctx", ".", "current_ns", ".", "aliases", "[", "ns_sym", "]", "v", "=", "Var", ".", "find", "(", "sym", ".", "symbol", "(", "form", ".", "name", ",", "ns", "=", "aliased_ns", ".", "name", ")", ")", "if", "v", "is", "None", ":", "raise", "ParserException", "(", "f\"unable to resolve symbol '{sym.symbol(form.name, ns_sym.name)}' in this context\"", ",", "form", "=", "form", ",", ")", "return", "VarRef", "(", "form", "=", "form", ",", "var", "=", "v", ",", "env", "=", "ctx", ".", "get_node_env", "(", ")", ")", "else", ":", "raise", "ParserException", "(", "f\"unable to resolve symbol '{form}' in this context\"", ",", "form", "=", "form", ")" ]

[ "Resolve", "a", "namespaced", "symbol", "into", "a", "Python", "name", "or", "Basilisp", "Var", "." ]

[ "def", "delete_dns_server", "(", "self", ",", "service_name", ",", "deployment_name", ",", "dns_server_name", ")", ":", "_validate_not_none", "(", "'service_name'", ",", "service_name", ")", "_validate_not_none", "(", "'deployment_name'", ",", "deployment_name", ")", "_validate_not_none", "(", "'dns_server_name'", ",", "dns_server_name", ")", "return", "self", ".", "_perform_delete", "(", "self", ".", "_get_dns_server_path", "(", "service_name", ",", "deployment_name", ",", "dns_server_name", ")", ",", "as_async", "=", "True", ")" ]

[ "Deletes", "a", "DNS", "server", "from", "a", "deployment", "." ]

[ "def", "extract_helices_dssp", "(", "in_pdb", ")", ":", "from", "ampal", ".", "pdb_parser", "import", "split_pdb_lines", "dssp_out", "=", "subprocess", ".", "check_output", "(", "[", "global_settings", "[", "'dssp'", "]", "[", "'path'", "]", ",", "in_pdb", "]", ")", "helix", "=", "0", "helices", "=", "[", "]", "h_on", "=", "False", "for", "line", "in", "dssp_out", ".", "splitlines", "(", ")", ":", "dssp_line", "=", "line", ".", "split", "(", ")", "try", ":", "if", "dssp_line", "[", "4", "]", "==", "'H'", ":", "if", "helix", "not", "in", "[", "x", "[", "0", "]", "for", "x", "in", "helices", "]", ":", "helices", ".", "append", "(", "[", "helix", ",", "dssp_line", "[", "2", "]", ",", "{", "int", "(", "dssp_line", "[", "1", "]", ")", ":", "None", "}", "]", ")", "else", ":", "helices", "[", "helix", "]", "[", "2", "]", "[", "int", "(", "dssp_line", "[", "1", "]", ")", "]", "=", "None", "h_on", "=", "True", "else", ":", "if", "h_on", ":", "helix", "+=", "1", "h_on", "=", "False", "except", "IndexError", ":", "pass", "with", "open", "(", "in_pdb", ",", "'r'", ")", "as", "pdb", ":", "pdb_atoms", "=", "split_pdb_lines", "(", "pdb", ".", "read", "(", ")", ")", "for", "atom", "in", "pdb_atoms", ":", "for", "helix", "in", "helices", ":", "if", "(", "atom", "[", "2", "]", "==", "\"CA\"", ")", "and", "(", "atom", "[", "5", "]", "==", "helix", "[", "1", "]", ")", "and", "(", "atom", "[", "6", "]", "in", "helix", "[", "2", "]", ".", "keys", "(", ")", ")", ":", "helix", "[", "2", "]", "[", "atom", "[", "6", "]", "]", "=", "tuple", "(", "atom", "[", "8", ":", "11", "]", ")", "return", "helices" ]

[ "Uses", "DSSP", "to", "find", "alpha", "-", "helices", "and", "extracts", "helices", "from", "a", "pdb", "file", "." ]

[ "def", "getProcessStats", "(", "self", ")", ":", "info_dict", "=", "{", "}", "try", ":", "fp", "=", "open", "(", "cpustatFile", ",", "'r'", ")", "data", "=", "fp", ".", "read", "(", ")", "fp", ".", "close", "(", ")", "except", ":", "raise", "IOError", "(", "'Failed reading stats from file: %s'", "%", "cpustatFile", ")", "for", "line", "in", "data", ".", "splitlines", "(", ")", ":", "arr", "=", "line", ".", "split", "(", ")", "if", "len", "(", "arr", ")", ">", "1", "and", "arr", "[", "0", "]", "in", "(", "'ctxt'", ",", "'intr'", ",", "'softirq'", ",", "'processes'", ",", "'procs_running'", ",", "'procs_blocked'", ")", ":", "info_dict", "[", "arr", "[", "0", "]", "]", "=", "arr", "[", "1", "]", "return", "info_dict" ]

[ "Return", "stats", "for", "running", "and", "blocked", "processes", "forks", "context", "switches", "and", "interrupts", "." ]

[ "def", "stderr", "(", "msg", ",", "silent", "=", "False", ")", ":", "if", "not", "silent", ":", "print", "(", "msg", ",", "file", "=", "sys", ".", "stderr", ")" ]

[ "write", "msg", "to", "stderr", "if", "not", "silent" ]

[ "def", "_init_oauth", "(", "self", ",", "oauth_token", ",", "oauth_token_secret", ")", ":", "self", ".", "oauth_token", "=", "oauth_token", "self", ".", "oauth_token_secret", "=", "oauth_token_secret", "self", ".", "_oauth", "=", "OAuth1", "(", "self", ".", "consumer_key", ",", "client_secret", "=", "self", ".", "consumer_secret", ",", "resource_owner_key", "=", "self", ".", "oauth_token", ",", "resource_owner_secret", "=", "self", ".", "oauth_token_secret", ",", "rsa_key", "=", "self", ".", "rsa_key", ",", "signature_method", "=", "self", ".", "_signature_method", ")" ]

[ "Store", "and", "initialize", "a", "verified", "set", "of", "OAuth", "credentials" ]

[ "def", "transform", "(", "list", ",", "pattern", ",", "indices", "=", "[", "1", "]", ")", ":", "result", "=", "[", "]", "for", "e", "in", "list", ":", "m", "=", "re", ".", "match", "(", "pattern", ",", "e", ")", "if", "m", ":", "for", "i", "in", "indices", ":", "result", ".", "append", "(", "m", ".", "group", "(", "i", ")", ")", "return", "result" ]

[ "Matches", "all", "elements", "of", "list", "agains", "the", "pattern", "and", "returns", "a", "list", "of", "the", "elements", "indicated", "by", "indices", "of", "all", "successfull", "matches", ".", "If", "indices", "is", "omitted", "returns", "a", "list", "of", "first", "paranthethised", "groups", "of", "all", "successfull", "matches", "." ]

[ "def", "get_area_def", "(", "self", ",", "dsid", ")", ":", "msg", "=", "self", ".", "_get_message", "(", "self", ".", "_msg_datasets", "[", "dsid", "]", ")", "try", ":", "return", "self", ".", "_area_def_from_msg", "(", "msg", ")", "except", "(", "RuntimeError", ",", "KeyError", ")", ":", "raise", "RuntimeError", "(", "\"Unknown GRIB projection information\"", ")" ]

[ "Get", "area", "definition", "for", "message", "." ]

[ "def", "recursive_build_tree", "(", "self", ",", "intervals", ")", ":", "center", "=", "int", "(", "round", "(", "len", "(", "intervals", ")", "/", "2", ")", ")", "left", "=", "intervals", "[", ":", "center", "]", "right", "=", "intervals", "[", "center", "+", "1", ":", "]", "node", "=", "intervals", "[", "center", "]", "if", "len", "(", "left", ")", ">", "1", ":", "left", "=", "self", ".", "recursive_build_tree", "(", "left", ")", "elif", "len", "(", "left", ")", "==", "1", ":", "left", "=", "[", "left", "[", "0", "]", ",", "[", "-", "1", ",", "-", "1", ",", "-", "1", ",", "[", "]", "]", ",", "[", "-", "1", ",", "-", "1", ",", "-", "1", ",", "[", "]", "]", ",", "[", "]", "]", "else", ":", "left", "=", "[", "-", "1", ",", "-", "1", ",", "-", "1", ",", "[", "]", "]", "if", "len", "(", "right", ")", ">", "1", ":", "right", "=", "self", ".", "recursive_build_tree", "(", "right", ")", "elif", "len", "(", "right", ")", "==", "1", ":", "right", "=", "[", "right", "[", "0", "]", ",", "[", "-", "1", ",", "-", "1", ",", "-", "1", ",", "[", "]", "]", ",", "[", "-", "1", ",", "-", "1", ",", "-", "1", ",", "[", "]", "]", ",", "[", "]", "]", "else", ":", "right", "=", "[", "-", "1", ",", "-", "1", ",", "-", "1", ",", "[", "]", "]", "return", "[", "node", ",", "left", ",", "right", ",", "[", "]", "]" ]

[ "recursively", "builds", "a", "BST", "based", "on", "the", "elementary", "intervals", ".", "each", "node", "is", "an", "array", ":", "[", "interval", "value", "left", "descendent", "nodes", "right", "descendent", "nodes", "[", "ids", "]]", ".", "nodes", "with", "no", "descendents", "have", "a", "-", "1", "value", "in", "left", "/", "right", "descendent", "positions", "." ]

[ "def", "add_service", "(", "self", ",", "service", ")", ":", "if", "service", ".", "protocol", "in", "self", ".", "_services", ":", "existing", "=", "self", ".", "_services", "[", "service", ".", "protocol", "]", "if", "not", "existing", ".", "superseeded_by", "(", "service", ")", ":", "return", "self", ".", "_services", "[", "service", ".", "protocol", "]", "=", "service" ]

[ "Add", "a", "new", "service", "." ]

[ "def", "validate_examples", "(", "example_file", ")", ":", "def", "test_example", "(", "raw", ")", ":", "example", "=", "tf", ".", "train", ".", "Example", "(", ")", "example", ".", "ParseFromString", "(", "raw", ")", "pi", "=", "np", ".", "frombuffer", "(", "example", ".", "features", ".", "feature", "[", "'pi'", "]", ".", "bytes_list", ".", "value", "[", "0", "]", ",", "np", ".", "float32", ")", "value", "=", "example", ".", "features", ".", "feature", "[", "'outcome'", "]", ".", "float_list", ".", "value", "[", "0", "]", "assert", "abs", "(", "pi", ".", "sum", "(", ")", "-", "1", ")", "<", "1e-4", ",", "pi", ".", "sum", "(", ")", "assert", "value", "in", "(", "-", "1", ",", "1", ")", ",", "value", "opts", "=", "tf", ".", "python_io", ".", "TFRecordOptions", "(", "tf", ".", "python_io", ".", "TFRecordCompressionType", ".", "ZLIB", ")", "for", "record", "in", "tqdm", "(", "tf", ".", "python_io", ".", "tf_record_iterator", "(", "example_file", ",", "opts", ")", ")", ":", "test_example", "(", "record", ")" ]

[ "Validate", "that", "examples", "are", "well", "formed", "." ]

[ "def", "_dedup_item", "(", "self", ",", "key", ",", "val", ",", "on_dup", ")", ":", "fwdm", "=", "self", ".", "_fwdm", "invm", "=", "self", ".", "_invm", "oldval", "=", "fwdm", ".", "get", "(", "key", ",", "_MISS", ")", "oldkey", "=", "invm", ".", "get", "(", "val", ",", "_MISS", ")", "isdupkey", "=", "oldval", "is", "not", "_MISS", "isdupval", "=", "oldkey", "is", "not", "_MISS", "dedup_result", "=", "_DedupResult", "(", "isdupkey", ",", "isdupval", ",", "oldkey", ",", "oldval", ")", "if", "isdupkey", "and", "isdupval", ":", "if", "self", ".", "_isdupitem", "(", "key", ",", "val", ",", "dedup_result", ")", ":", "# (key, val) duplicates an existing item -> no-op.", "return", "_NOOP", "# key and val each duplicate a different existing item.", "if", "on_dup", ".", "kv", "is", "RAISE", ":", "raise", "KeyAndValueDuplicationError", "(", "key", ",", "val", ")", "elif", "on_dup", ".", "kv", "is", "IGNORE", ":", "return", "_NOOP", "assert", "on_dup", ".", "kv", "is", "OVERWRITE", ",", "'invalid on_dup_kv: %r'", "%", "on_dup", ".", "kv", "# Fall through to the return statement on the last line.", "elif", "isdupkey", ":", "if", "on_dup", ".", "key", "is", "RAISE", ":", "raise", "KeyDuplicationError", "(", "key", ")", "elif", "on_dup", ".", "key", "is", "IGNORE", ":", "return", "_NOOP", "assert", "on_dup", ".", "key", "is", "OVERWRITE", ",", "'invalid on_dup.key: %r'", "%", "on_dup", ".", "key", "# Fall through to the return statement on the last line.", "elif", "isdupval", ":", "if", "on_dup", ".", "val", "is", "RAISE", ":", "raise", "ValueDuplicationError", "(", "val", ")", "elif", "on_dup", ".", "val", "is", "IGNORE", ":", "return", "_NOOP", "assert", "on_dup", ".", "val", "is", "OVERWRITE", ",", "'invalid on_dup.val: %r'", "%", "on_dup", ".", "val", "# Fall through to the return statement on the last line.", "# else neither isdupkey nor isdupval.", "return", "dedup_result" ]

[ "Check", "*", "key", "*", "and", "*", "val", "*", "for", "any", "duplication", "in", "self", "." ]

[ "def", "mount_disks", "(", "self", ")", ":", "result", "=", "True", "for", "disk", "in", "self", ".", "disks", ":", "result", "=", "disk", ".", "mount", "(", ")", "and", "result", "return", "result" ]

[ "Mounts", "all", "disks", "in", "the", "parser", "i", ".", "e", ".", "calling", ":", "func", ":", "Disk", ".", "mount", "on", "all", "underlying", "disks", ".", "You", "probably", "want", "to", "use", ":", "func", ":", "init", "instead", "." ]

[ "def", "retrieve", "(", "self", ",", "*", "args", ")", ":", "ret", "=", "self", ".", "_base_retrieve", "(", "args", ")", "if", "ret", "is", "None", ":", "raise", "HistoryError", "(", "\"Set, then deleted\"", ",", "deleted", "=", "True", ")", "elif", "ret", "is", "KeyError", ":", "raise", "ret", "return", "ret" ]

[ "Get", "a", "value", "previously", ".", "store", "(", "...", ")", "d", "." ]

[ "def", "on_change", "(", "self", ",", "path", ",", "event_type", ")", ":", "# I can do all this work in a sql statement, but", "# for debugging it's easier to do it in stages.", "sql", "=", "\"\"\"SELECT collection_id\n FROM collection_table\n WHERE path == ?\n \"\"\"", "cursor", "=", "self", ".", "_execute", "(", "sql", ",", "(", "path", ",", ")", ")", "results", "=", "cursor", ".", "fetchall", "(", ")", "# there should always be exactly one result, but", "# there's no harm in using a loop to process the", "# single result", "for", "result", "in", "results", ":", "collection_id", "=", "result", "[", "0", "]", "# remove all keywords in this collection", "sql", "=", "\"\"\"DELETE from keyword_table\n WHERE collection_id == ?\n \"\"\"", "cursor", "=", "self", ".", "_execute", "(", "sql", ",", "(", "collection_id", ",", ")", ")", "self", ".", "_load_keywords", "(", "collection_id", ",", "path", "=", "path", ")" ]

[ "Respond", "to", "changes", "in", "the", "file", "system" ]

[ "def", "point_line_distance", "(", "p", ",", "l_p", ",", "l_v", ")", ":", "l_v", "=", "normalize", "(", "l_v", ")", "u", "=", "p", "-", "l_p", "return", "np", ".", "linalg", ".", "norm", "(", "u", "-", "np", ".", "dot", "(", "u", ",", "l_v", ")", "*", "l_v", ")" ]

[ "Calculate", "the", "distance", "between", "a", "point", "and", "a", "line", "defined", "by", "a", "point", "and", "a", "direction", "vector", "." ]

[ "def", "plot_sfs_folded_scaled", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "kwargs", ".", "setdefault", "(", "'yscale'", ",", "'linear'", ")", "ax", "=", "plot_sfs_folded", "(", "*", "args", ",", "*", "*", "kwargs", ")", "ax", ".", "set_ylabel", "(", "'scaled site frequency'", ")", "n", "=", "kwargs", ".", "get", "(", "'n'", ",", "None", ")", "if", "n", ":", "ax", ".", "set_xlabel", "(", "'minor allele frequency'", ")", "else", ":", "ax", ".", "set_xlabel", "(", "'minor allele count'", ")", "return", "ax" ]

[ "Plot", "a", "folded", "scaled", "site", "frequency", "spectrum", "." ]

[ "def", "apply", "(", "self", ")", ":", "# In this phase, we replace the substitutions in hyperlinks", "# with the contents of the sub-nodes introduced during phase 1.", "# We also remove those temporary nodes from the tree.", "subst_re", "=", "re", ".", "compile", "(", "self", ".", "subst_pattern", ")", "# Apply the substitutions to hyperlink references.", "for", "link", "in", "self", ".", "document", ".", "traverse", "(", "nodes", ".", "reference", ")", ":", "substitutions", "=", "link", ".", "get", "(", "'varlinks'", ")", "if", "not", "substitutions", ":", "continue", "replacer", "=", "self", ".", "_replace", "(", "substitutions", ",", "link", ".", "children", ",", "1", ")", "link", "[", "'refuri'", "]", "=", "subst_re", ".", "sub", "(", "replacer", ",", "link", "[", "'refuri'", "]", ")", "content", "=", "subst_re", ".", "sub", "(", "replacer", ",", "link", "[", "0", "]", ")", "# Cleanup the temporary nodes and recreate the node's content.", "link", ".", "clear", "(", ")", "del", "link", "[", "'varlinks'", "]", "link", ".", "append", "(", "nodes", ".", "Text", "(", "content", ")", ")", "# Do the same with hyperlink targets.", "for", "link", "in", "self", ".", "document", ".", "traverse", "(", "nodes", ".", "target", ")", ":", "substitutions", "=", "link", ".", "get", "(", "'varlinks'", ")", "if", "not", "substitutions", ":", "continue", "replacer", "=", "self", ".", "_replace", "(", "substitutions", ",", "link", ".", "children", ",", "0", ")", "link", "[", "'refuri'", "]", "=", "subst_re", ".", "sub", "(", "replacer", ",", "link", "[", "'refuri'", "]", ")", "# Cleanup the temporary nodes.", "link", ".", "clear", "(", ")", "del", "link", "[", "'varlinks'", "]" ]

[ "Replace", "substitutions", "in", "hyperlinks", "with", "their", "contents" ]

[ "def", "byteswap", "(", "data", ",", "word_size", "=", "4", ")", ":", "return", "reduce", "(", "lambda", "x", ",", "y", ":", "x", "+", "''", ".", "join", "(", "reversed", "(", "y", ")", ")", ",", "chunks", "(", "data", ",", "word_size", ")", ",", "''", ")" ]

[ "Swap", "the", "byte", "-", "ordering", "in", "a", "packet", "with", "N", "=", "4", "bytes", "per", "word" ]

[ "def", "render_template", "(", "tpl", ",", "context", ")", ":", "templates", "=", "[", "tpl", "]", "if", "type", "(", "tpl", ")", "!=", "list", "else", "tpl", "tpl_instance", "=", "None", "for", "tpl", "in", "templates", ":", "try", ":", "tpl_instance", "=", "template", ".", "loader", ".", "get_template", "(", "tpl", ")", "break", "except", "template", ".", "TemplateDoesNotExist", ":", "pass", "if", "not", "tpl_instance", ":", "raise", "Exception", "(", "'Template does not exist: '", "+", "templates", "[", "-", "1", "]", ")", "return", "tpl_instance", ".", "render", "(", "template", ".", "Context", "(", "context", ")", ")" ]

[ "A", "shortcut", "function", "to", "render", "a", "partial", "template", "with", "context", "and", "return", "the", "output", "." ]

[ "def", "huffman_conv2str", "(", "cls", ",", "bit_str", ",", "bit_len", ")", ":", "# type: (int, int) -> str", "assert", "(", "bit_str", ">=", "0", ")", "assert", "(", "bit_len", ">=", "0", ")", "byte_len", "=", "bit_len", "//", "8", "rem_bit", "=", "bit_len", "%", "8", "if", "rem_bit", "!=", "0", ":", "bit_str", "<<=", "8", "-", "rem_bit", "byte_len", "+=", "1", "# As usual the list/join tricks is a performance trick to build", "# efficiently a Python string", "s", "=", "[", "]", "# type: List[str]", "i", "=", "0", "while", "i", "<", "byte_len", ":", "s", ".", "insert", "(", "0", ",", "chb", "(", "(", "bit_str", ">>", "(", "i", "*", "8", ")", ")", "&", "0xFF", ")", ")", "i", "+=", "1", "return", "b''", ".", "join", "(", "s", ")" ]

[ "huffman_conv2str", "converts", "a", "bitstring", "of", "bit_len", "bitlength", "into", "a", "binary", "string", ".", "It", "DOES", "NOT", "compress", "/", "decompress", "the", "bitstring!" ]

[ "def", "ensure_scheme", "(", "url", ",", "default_scheme", "=", "'http'", ")", ":", "parsed", "=", "urlsplit", "(", "url", ",", "scheme", "=", "default_scheme", ")", "if", "not", "parsed", ".", "netloc", ":", "parsed", "=", "SplitResult", "(", "scheme", "=", "parsed", ".", "scheme", ",", "netloc", "=", "parsed", ".", "path", ",", "path", "=", "''", ",", "query", "=", "parsed", ".", "query", ",", "fragment", "=", "parsed", ".", "fragment", ")", "return", "urlunsplit", "(", "parsed", ")" ]

[ "Adds", "a", "scheme", "to", "a", "url", "if", "not", "present", "." ]

[ "def", "to_bool", "(", "value", ",", "do_raise", "=", "True", ")", ":", "value", "=", "value", ".", "lower", "(", ")", "# Try it as an integer", "if", "value", ".", "isdigit", "(", ")", ":", "return", "bool", "(", "int", "(", "value", ")", ")", "# OK, check it against the true/false values...", "if", "value", "in", "_str_true", ":", "return", "True", "elif", "value", "in", "_str_false", ":", "return", "False", "# Not recognized", "if", "do_raise", ":", "raise", "ValueError", "(", "\"invalid literal for to_bool(): %r\"", "%", "value", ")", "return", "False" ]

[ "Convert", "a", "string", "to", "a", "boolean", "value", "." ]

[ "def", "references", "(", "self", ")", ":", "refs", "=", "self", ".", "items", ".", "find", "(", "'bibrecord/tail/bibliography'", ",", "ns", ")", "if", "refs", "is", "not", "None", ":", "eids", "=", "[", "r", ".", "find", "(", "\"ref-info/refd-itemidlist/itemid\"", ",", "ns", ")", ".", "text", "for", "r", "in", "refs", ".", "findall", "(", "\"reference\"", ",", "ns", ")", "]", "return", "[", "\"2-s2.0-\"", "+", "eid", "for", "eid", "in", "eids", "]", "else", ":", "return", "None" ]

[ "Return", "EIDs", "of", "references", "of", "an", "article", ".", "Note", ":", "Requires", "the", "FULL", "view", "of", "the", "article", "." ]

[ "def", "get_hdd_only_candidate_models", "(", "data", ",", "minimum_non_zero_hdd", ",", "minimum_total_hdd", ",", "beta_hdd_maximum_p_value", ",", "weights_col", ")", ":", "balance_points", "=", "[", "int", "(", "col", "[", "4", ":", "]", ")", "for", "col", "in", "data", ".", "columns", "if", "col", ".", "startswith", "(", "\"hdd\"", ")", "]", "candidate_models", "=", "[", "get_single_hdd_only_candidate_model", "(", "data", ",", "minimum_non_zero_hdd", ",", "minimum_total_hdd", ",", "beta_hdd_maximum_p_value", ",", "weights_col", ",", "balance_point", ",", ")", "for", "balance_point", "in", "balance_points", "]", "return", "candidate_models" ]

[ "Parameters", "----------", "data", ":", ":", "any", ":", "pandas", ".", "DataFrame", "A", "DataFrame", "containing", "at", "least", "the", "column", "meter_value", "and", "1", "to", "n", "columns", "with", "names", "of", "the", "form", "hdd_<balance_point", ">", ".", "All", "columns", "with", "names", "of", "this", "form", "will", "be", "used", "to", "fit", "a", "candidate", "model", ".", "DataFrames", "of", "this", "form", "can", "be", "made", "using", "the", ":", "any", ":", "eemeter", ".", "create_caltrack_daily_design_matrix", "or", ":", "any", ":", "eemeter", ".", "create_caltrack_billing_design_matrix", "methods", ".", "minimum_non_zero_hdd", ":", ":", "any", ":", "int", "Minimum", "allowable", "number", "of", "non", "-", "zero", "heating", "degree", "day", "values", ".", "minimum_total_hdd", ":", ":", "any", ":", "float", "Minimum", "allowable", "total", "sum", "of", "heating", "degree", "day", "values", ".", "beta_hdd_maximum_p_value", ":", ":", "any", ":", "float", "The", "maximum", "allowable", "p", "-", "value", "of", "the", "beta", "hdd", "parameter", ".", "weights_col", ":", ":", "any", ":", "str", "or", "None", "The", "name", "of", "the", "column", "(", "if", "any", ")", "in", "data", "to", "use", "as", "weights", "." ]

[ "def", "npz_generator", "(", "npz_path", ")", ":", "npz_data", "=", "np", ".", "load", "(", "npz_path", ")", "X", "=", "npz_data", "[", "'X'", "]", "# Y is a binary maxtrix with shape=(n, k), each y will have shape=(k,)", "y", "=", "npz_data", "[", "'Y'", "]", "n", "=", "X", ".", "shape", "[", "0", "]", "while", "True", ":", "i", "=", "np", ".", "random", ".", "randint", "(", "0", ",", "n", ")", "yield", "{", "'X'", ":", "X", "[", "i", "]", ",", "'Y'", ":", "y", "[", "i", "]", "}" ]

[ "Generate", "data", "from", "an", "npz", "file", "." ]

[ "def", "argument_request_user", "(", "obj", ",", "func_name", ")", ":", "func", "=", "getattr", "(", "obj", ",", "func_name", ")", "request", "=", "threadlocals", ".", "request", "(", ")", "if", "request", ":", "return", "func", "(", "request", ".", "user", ")" ]

[ "Pass", "request", ".", "user", "as", "an", "argument", "to", "the", "given", "function", "call", "." ]

[ "def", "set_servo_pulsewidth", "(", "self", ",", "user_gpio", ",", "pulsewidth", ")", ":", "res", "=", "yield", "from", "self", ".", "_pigpio_aio_command", "(", "_PI_CMD_SERVO", ",", "user_gpio", ",", "int", "(", "pulsewidth", ")", ")", "return", "_u2i", "(", "res", ")" ]

[ "Starts", "(", "500", "-", "2500", ")", "or", "stops", "(", "0", ")", "servo", "pulses", "on", "the", "GPIO", ".", "user_gpio", ":", "=", "0", "-", "31", ".", "pulsewidth", ":", "=", "0", "(", "off", ")", "500", "(", "most", "anti", "-", "clockwise", ")", "-", "2500", "(", "most", "clockwise", ")", ".", "The", "selected", "pulsewidth", "will", "continue", "to", "be", "transmitted", "until", "changed", "by", "a", "subsequent", "call", "to", "set_servo_pulsewidth", ".", "The", "pulsewidths", "supported", "by", "servos", "varies", "and", "should", "probably", "be", "determined", "by", "experiment", ".", "A", "value", "of", "1500", "should", "always", "be", "safe", "and", "represents", "the", "mid", "-", "point", "of", "rotation", ".", "You", "can", "DAMAGE", "a", "servo", "if", "you", "command", "it", "to", "move", "beyond", "its", "limits", ".", "...", "yield", "from", "pi", ".", "set_servo_pulsewidth", "(", "17", "0", ")", "#", "off", "yield", "from", "pi", ".", "set_servo_pulsewidth", "(", "17", "1000", ")", "#", "safe", "anti", "-", "clockwise", "yield", "from", "pi", ".", "set_servo_pulsewidth", "(", "17", "1500", ")", "#", "centre", "yield", "from", "pi", ".", "set_servo_pulsewidth", "(", "17", "2000", ")", "#", "safe", "clockwise", "..." ]

[ "def", "processEnded", "(", "self", ",", "reason", ")", ":", "log_debug", "(", "\"{name} process exited\"", ",", "name", "=", "self", ".", "name", ")", "if", "self", ".", "deferred", ":", "if", "reason", ".", "type", "==", "ProcessDone", ":", "self", ".", "deferred", ".", "callback", "(", "reason", ".", "value", ".", "exitCode", ")", "elif", "reason", ".", "type", "==", "ProcessTerminated", ":", "self", ".", "deferred", ".", "errback", "(", "reason", ")", "return", "self", ".", "deferred" ]

[ "Connected", "process", "shut", "down" ]

[ "def", "scale", "(", "data", ",", "zero_center", "=", "True", ",", "max_value", "=", "None", ",", "copy", "=", "False", ")", "->", "Optional", "[", "AnnData", "]", ":", "if", "isinstance", "(", "data", ",", "AnnData", ")", ":", "adata", "=", "data", ".", "copy", "(", ")", "if", "copy", "else", "data", "# need to add the following here to make inplace logic work", "if", "zero_center", "and", "issparse", "(", "adata", ".", "X", ")", ":", "logg", ".", "msg", "(", "'... scale_data: as `zero_center=True`, sparse input is '", "'densified and may lead to large memory consumption'", ")", "adata", ".", "X", "=", "adata", ".", "X", ".", "toarray", "(", ")", "scale", "(", "adata", ".", "X", ",", "zero_center", "=", "zero_center", ",", "max_value", "=", "max_value", ",", "copy", "=", "False", ")", "return", "adata", "if", "copy", "else", "None", "X", "=", "data", ".", "copy", "(", ")", "if", "copy", "else", "data", "# proceed with the data matrix", "zero_center", "=", "zero_center", "if", "zero_center", "is", "not", "None", "else", "False", "if", "issparse", "(", "X", ")", "else", "True", "if", "not", "zero_center", "and", "max_value", "is", "not", "None", ":", "logg", ".", "msg", "(", "'... scale_data: be careful when using `max_value` without `zero_center`'", ",", "v", "=", "4", ")", "if", "max_value", "is", "not", "None", ":", "logg", ".", "msg", "(", "'... clipping at max_value'", ",", "max_value", ")", "if", "zero_center", "and", "issparse", "(", "X", ")", ":", "logg", ".", "msg", "(", "'... scale_data: as `zero_center=True`, sparse input is '", "'densified and may lead to large memory consumption, returning copy'", ",", "v", "=", "4", ")", "X", "=", "X", ".", "toarray", "(", ")", "copy", "=", "True", "_scale", "(", "X", ",", "zero_center", ")", "if", "max_value", "is", "not", "None", ":", "X", "[", "X", ">", "max_value", "]", "=", "max_value", "return", "X", "if", "copy", "else", "None" ]

[ "Scale", "data", "to", "unit", "variance", "and", "zero", "mean", "." ]

[ "def", "is_tag_matched", "(", "self", ",", "tag", ",", "*", "*", "attribute_filter", ")", ":", "if", "len", "(", "attribute_filter", ")", "<=", "0", ":", "return", "True", "for", "attr", ",", "value", "in", "attribute_filter", ".", "items", "(", ")", ":", "_value", "=", "self", ".", "get_value_from_tag", "(", "tag", ",", "attr", ")", "if", "_value", "!=", "value", ":", "return", "False", "return", "True" ]

[ "r", "Return", "true", "if", "the", "attributes", "matches", "in", "attribute", "filter", "." ]

[ "def", "get_gpu_memory_usage", "(", "ctx", ":", "List", "[", "mx", ".", "context", ".", "Context", "]", ")", "->", "Dict", "[", "int", ",", "Tuple", "[", "int", ",", "int", "]", "]", ":", "if", "isinstance", "(", "ctx", ",", "mx", ".", "context", ".", "Context", ")", ":", "ctx", "=", "[", "ctx", "]", "ctx", "=", "[", "c", "for", "c", "in", "ctx", "if", "c", ".", "device_type", "==", "'gpu'", "]", "if", "not", "ctx", ":", "return", "{", "}", "if", "shutil", ".", "which", "(", "\"nvidia-smi\"", ")", "is", "None", ":", "logger", ".", "warning", "(", "\"Couldn't find nvidia-smi, therefore we assume no GPUs are available.\"", ")", "return", "{", "}", "device_ids", "=", "[", "c", ".", "device_id", "for", "c", "in", "ctx", "]", "# Run from clean forkserver process to not leak any CUDA resources", "mp_context", "=", "mp_utils", ".", "get_context", "(", ")", "result_queue", "=", "mp_context", ".", "Queue", "(", ")", "nvidia_smi_process", "=", "mp_context", ".", "Process", "(", "target", "=", "query_nvidia_smi", ",", "args", "=", "(", "device_ids", ",", "result_queue", ",", ")", ")", "nvidia_smi_process", ".", "start", "(", ")", "nvidia_smi_process", ".", "join", "(", ")", "memory_data", "=", "result_queue", ".", "get", "(", ")", "log_gpu_memory_usage", "(", "memory_data", ")", "return", "memory_data" ]

[ "Returns", "used", "and", "total", "memory", "for", "GPUs", "identified", "by", "the", "given", "context", "list", "." ]

[ "async", "def", "declareWorkerType", "(", "self", ",", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "await", "self", ".", "_makeApiCall", "(", "self", ".", "funcinfo", "[", "\"declareWorkerType\"", "]", ",", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "Update", "a", "worker", "-", "type" ]

[ "def", "proc_monomer", "(", "self", ",", "monomer_info", ",", "parent", ",", "mon_cls", "=", "False", ")", ":", "monomer_labels", ",", "monomer_data", "=", "monomer_info", "if", "len", "(", "monomer_labels", ")", ">", "1", ":", "raise", "ValueError", "(", "'Malformed PDB, single monomer id with '", "'multiple labels. {}'", ".", "format", "(", "monomer_labels", ")", ")", "else", ":", "monomer_label", "=", "list", "(", "monomer_labels", ")", "[", "0", "]", "if", "mon_cls", ":", "monomer_class", "=", "mon_cls", "het", "=", "True", "elif", "monomer_label", "[", "0", "]", "==", "'ATOM'", ":", "if", "monomer_label", "[", "2", "]", "in", "standard_amino_acids", ".", "values", "(", ")", ":", "monomer_class", "=", "Residue", "else", ":", "monomer_class", "=", "Nucleotide", "het", "=", "False", "else", ":", "raise", "ValueError", "(", "'Unknown Monomer type.'", ")", "monomer", "=", "monomer_class", "(", "atoms", "=", "None", ",", "mol_code", "=", "monomer_label", "[", "2", "]", ",", "monomer_id", "=", "monomer_label", "[", "1", "]", ",", "insertion_code", "=", "monomer_label", "[", "3", "]", ",", "is_hetero", "=", "het", ",", "ampal_parent", "=", "parent", ")", "monomer", ".", "states", "=", "self", ".", "gen_states", "(", "monomer_data", ".", "values", "(", ")", ",", "monomer", ")", "monomer", ".", "_active_state", "=", "sorted", "(", "monomer", ".", "states", ".", "keys", "(", ")", ")", "[", "0", "]", "return", "monomer" ]

[ "Processes", "a", "records", "into", "a", "Monomer", "." ]

[ "def", "save", "(", "self", ",", "revision", ")", ":", "if", "not", "isinstance", "(", "revision", ",", "Revision", ")", ":", "raise", "InvalidArgType", "(", ")", "self", ".", "state", ".", "update", "(", "revision", ")" ]

[ ":", "param", "revision", ":", ":", "type", "revision", ":", ":", "class", ":", "revision", ".", "data", ".", "Revision" ]

[ "def", "get_filelist", "(", "run_module_names", ")", ":", "# Prep search patterns", "spatterns", "=", "[", "{", "}", ",", "{", "}", ",", "{", "}", ",", "{", "}", ",", "{", "}", ",", "{", "}", ",", "{", "}", "]", "epatterns", "=", "[", "{", "}", ",", "{", "}", "]", "ignored_patterns", "=", "[", "]", "for", "key", ",", "sps", "in", "config", ".", "sp", ".", "items", "(", ")", ":", "mod_name", "=", "key", ".", "split", "(", "'/'", ",", "1", ")", "[", "0", "]", "if", "mod_name", ".", "lower", "(", ")", "not", "in", "[", "m", ".", "lower", "(", ")", "for", "m", "in", "run_module_names", "]", ":", "ignored_patterns", ".", "append", "(", "key", ")", "continue", "files", "[", "key", "]", "=", "list", "(", ")", "if", "not", "isinstance", "(", "sps", ",", "list", ")", ":", "sps", "=", "[", "sps", "]", "# Warn if we have any unrecognised search pattern keys", "expected_sp_keys", "=", "[", "'fn'", ",", "'fn_re'", ",", "'contents'", ",", "'contents_re'", ",", "'num_lines'", ",", "'shared'", ",", "'max_filesize'", ",", "'exclude_fn'", ",", "'exclude_fn_re'", ",", "'exclude_contents'", ",", "'exclude_contents_re'", "]", "unrecognised_keys", "=", "[", "y", "for", "x", "in", "sps", "for", "y", "in", "x", ".", "keys", "(", ")", "if", "y", "not", "in", "expected_sp_keys", "]", "if", "len", "(", "unrecognised_keys", ")", ">", "0", ":", "logger", ".", "warn", "(", "\"Unrecognised search pattern keys for '{}': {}\"", ".", "format", "(", "key", ",", "', '", ".", "join", "(", "unrecognised_keys", ")", ")", ")", "# Split search patterns according to speed of execution.", "if", "any", "(", "[", "x", "for", "x", "in", "sps", "if", "'contents_re'", "in", "x", "]", ")", ":", "if", "any", "(", "[", "x", "for", "x", "in", "sps", "if", "'num_lines'", "in", "x", "]", ")", ":", "spatterns", "[", "4", "]", "[", "key", "]", "=", "sps", "elif", "any", "(", "[", "x", "for", "x", "in", "sps", "if", "'max_filesize'", "in", "x", "]", ")", ":", "spatterns", "[", "5", "]", "[", "key", "]", "=", "sps", "else", ":", "spatterns", "[", "6", "]", "[", "key", "]", "=", "sps", "elif", "any", "(", "[", "x", "for", "x", "in", "sps", "if", "'contents'", "in", "x", "]", ")", ":", "if", "any", "(", "[", "x", "for", "x", "in", "sps", "if", "'num_lines'", "in", "x", "]", ")", ":", "spatterns", "[", "1", "]", "[", "key", "]", "=", "sps", "elif", "any", "(", "[", "x", "for", "x", "in", "sps", "if", "'max_filesize'", "in", "x", "]", ")", ":", "spatterns", "[", "2", "]", "[", "key", "]", "=", "sps", "else", ":", "spatterns", "[", "3", "]", "[", "key", "]", "=", "sps", "else", ":", "spatterns", "[", "0", "]", "[", "key", "]", "=", "sps", "if", "len", "(", "ignored_patterns", ")", ">", "0", ":", "logger", ".", "debug", "(", "\"Ignored {} search patterns as didn't match running modules.\"", ".", "format", "(", "len", "(", "ignored_patterns", ")", ")", ")", "def", "add_file", "(", "fn", ",", "root", ")", ":", "\"\"\"\n Function applied to each file found when walking the analysis\n directories. Runs through all search patterns and returns True\n if a match is found.\n \"\"\"", "f", "=", "{", "'fn'", ":", "fn", ",", "'root'", ":", "root", "}", "# Check that this is a file and not a pipe or anything weird", "if", "not", "os", ".", "path", ".", "isfile", "(", "os", ".", "path", ".", "join", "(", "root", ",", "fn", ")", ")", ":", "return", "None", "# Check that we don't want to ignore this file", "i_matches", "=", "[", "n", "for", "n", "in", "config", ".", "fn_ignore_files", "if", "fnmatch", ".", "fnmatch", "(", "fn", ",", "n", ")", "]", "if", "len", "(", "i_matches", ")", ">", "0", ":", "logger", ".", "debug", "(", "\"Ignoring file as matched an ignore pattern: {}\"", ".", "format", "(", "fn", ")", ")", "return", "None", "# Limit search to small files, to avoid 30GB FastQ files etc.", "try", ":", "f", "[", "'filesize'", "]", "=", "os", ".", "path", ".", "getsize", "(", "os", ".", "path", ".", "join", "(", "root", ",", "fn", ")", ")", "except", "(", "IOError", ",", "OSError", ",", "ValueError", ",", "UnicodeDecodeError", ")", ":", "logger", ".", "debug", "(", "\"Couldn't read file when checking filesize: {}\"", ".", "format", "(", "fn", ")", ")", "else", ":", "if", "f", "[", "'filesize'", "]", ">", "config", ".", "log_filesize_limit", ":", "return", "False", "# Test file for each search pattern", "for", "patterns", "in", "spatterns", ":", "for", "key", ",", "sps", "in", "patterns", ".", "items", "(", ")", ":", "for", "sp", "in", "sps", ":", "if", "search_file", "(", "sp", ",", "f", ")", ":", "# Check that we shouldn't exclude this file", "if", "not", "exclude_file", "(", "sp", ",", "f", ")", ":", "# Looks good! Remember this file", "files", "[", "key", "]", ".", "append", "(", "f", ")", "# Don't keep searching this file for other modules", "if", "not", "sp", ".", "get", "(", "'shared'", ",", "False", ")", ":", "return", "# Don't look at other patterns for this module", "else", ":", "break", "# Go through the analysis directories and get file list", "for", "path", "in", "config", ".", "analysis_dir", ":", "if", "os", ".", "path", ".", "islink", "(", "path", ")", "and", "config", ".", "ignore_symlinks", ":", "continue", "elif", "os", ".", "path", ".", "isfile", "(", "path", ")", ":", "searchfiles", ".", "append", "(", "[", "os", ".", "path", ".", "basename", "(", "path", ")", ",", "os", ".", "path", ".", "dirname", "(", "path", ")", "]", ")", "elif", "os", ".", "path", ".", "isdir", "(", "path", ")", ":", "for", "root", ",", "dirnames", ",", "filenames", "in", "os", ".", "walk", "(", "path", ",", "followlinks", "=", "(", "not", "config", ".", "ignore_symlinks", ")", ",", "topdown", "=", "True", ")", ":", "bname", "=", "os", ".", "path", ".", "basename", "(", "root", ")", "# Skip any sub-directories matching ignore params", "orig_dirnames", "=", "dirnames", "[", ":", "]", "for", "n", "in", "config", ".", "fn_ignore_dirs", ":", "dirnames", "[", ":", "]", "=", "[", "d", "for", "d", "in", "dirnames", "if", "not", "fnmatch", ".", "fnmatch", "(", "d", ",", "n", ".", "rstrip", "(", "os", ".", "sep", ")", ")", "]", "if", "len", "(", "orig_dirnames", ")", "!=", "len", "(", "dirnames", ")", ":", "removed_dirs", "=", "[", "os", ".", "path", ".", "join", "(", "root", ",", "d", ")", "for", "d", "in", "set", "(", "orig_dirnames", ")", ".", "symmetric_difference", "(", "set", "(", "dirnames", ")", ")", "]", "logger", ".", "debug", "(", "\"Ignoring directory as matched fn_ignore_dirs: {}\"", ".", "format", "(", "\", \"", ".", "join", "(", "removed_dirs", ")", ")", ")", "orig_dirnames", "=", "dirnames", "[", ":", "]", "for", "n", "in", "config", ".", "fn_ignore_paths", ":", "dirnames", "[", ":", "]", "=", "[", "d", "for", "d", "in", "dirnames", "if", "not", "fnmatch", ".", "fnmatch", "(", "os", ".", "path", ".", "join", "(", "root", ",", "d", ")", ",", "n", ".", "rstrip", "(", "os", ".", "sep", ")", ")", "]", "if", "len", "(", "orig_dirnames", ")", "!=", "len", "(", "dirnames", ")", ":", "removed_dirs", "=", "[", "os", ".", "path", ".", "join", "(", "root", ",", "d", ")", "for", "d", "in", "set", "(", "orig_dirnames", ")", ".", "symmetric_difference", "(", "set", "(", "dirnames", ")", ")", "]", "logger", ".", "debug", "(", "\"Ignoring directory as matched fn_ignore_paths: {}\"", ".", "format", "(", "\", \"", ".", "join", "(", "removed_dirs", ")", ")", ")", "# Skip *this* directory if matches ignore params", "d_matches", "=", "[", "n", "for", "n", "in", "config", ".", "fn_ignore_dirs", "if", "fnmatch", ".", "fnmatch", "(", "bname", ",", "n", ".", "rstrip", "(", "os", ".", "sep", ")", ")", "]", "if", "len", "(", "d_matches", ")", ">", "0", ":", "logger", ".", "debug", "(", "\"Ignoring directory as matched fn_ignore_dirs: {}\"", ".", "format", "(", "bname", ")", ")", "continue", "p_matches", "=", "[", "n", "for", "n", "in", "config", ".", "fn_ignore_paths", "if", "fnmatch", ".", "fnmatch", "(", "root", ",", "n", ".", "rstrip", "(", "os", ".", "sep", ")", ")", "]", "if", "len", "(", "p_matches", ")", ">", "0", ":", "logger", ".", "debug", "(", "\"Ignoring directory as matched fn_ignore_paths: {}\"", ".", "format", "(", "root", ")", ")", "continue", "# Search filenames in this directory", "for", "fn", "in", "filenames", ":", "searchfiles", ".", "append", "(", "[", "fn", ",", "root", "]", ")", "# Search through collected files", "with", "click", ".", "progressbar", "(", "searchfiles", ",", "label", "=", "\"Searching {} files..\"", ".", "format", "(", "len", "(", "searchfiles", ")", ")", ")", "as", "sfiles", ":", "for", "sf", "in", "sfiles", ":", "add_file", "(", "sf", "[", "0", "]", ",", "sf", "[", "1", "]", ")" ]

[ "Go", "through", "all", "supplied", "search", "directories", "and", "assembly", "a", "master", "list", "of", "files", "to", "search", ".", "Then", "fire", "search", "functions", "for", "each", "file", "." ]

[ "def", "lookupAll", "(", "data", ",", "configFields", ",", "lookupType", ",", "db", ",", "histObj", "=", "{", "}", ")", ":", "for", "field", "in", "data", ".", "keys", "(", ")", ":", "if", "field", "in", "configFields", ".", "keys", "(", ")", "and", "data", "[", "field", "]", "!=", "''", ":", "if", "lookupType", "in", "configFields", "[", "field", "]", "[", "\"lookup\"", "]", ":", "if", "lookupType", "in", "[", "'genericLookup'", ",", "'fieldSpecificLookup'", ",", "'normLookup'", "]", ":", "fieldValNew", ",", "histObj", "=", "DataLookup", "(", "fieldVal", "=", "data", "[", "field", "]", ",", "db", "=", "db", ",", "lookupType", "=", "lookupType", ",", "fieldName", "=", "field", ",", "histObj", "=", "histObj", ")", "elif", "lookupType", "in", "[", "'genericRegex'", ",", "'fieldSpecificRegex'", ",", "'normRegex'", "]", ":", "fieldValNew", ",", "histObj", "=", "RegexLookup", "(", "fieldVal", "=", "data", "[", "field", "]", ",", "db", "=", "db", ",", "fieldName", "=", "field", ",", "lookupType", "=", "lookupType", ",", "histObj", "=", "histObj", ")", "elif", "lookupType", "==", "'normIncludes'", ":", "fieldValNew", ",", "histObj", ",", "checkMatch", "=", "IncludesLookup", "(", "fieldVal", "=", "data", "[", "field", "]", ",", "lookupType", "=", "'normIncludes'", ",", "db", "=", "db", ",", "fieldName", "=", "field", ",", "histObj", "=", "histObj", ")", "data", "[", "field", "]", "=", "fieldValNew", "return", "data", ",", "histObj" ]

[ "Return", "a", "record", "after", "having", "cleaning", "rules", "of", "specified", "type", "applied", "to", "all", "fields", "in", "the", "config" ]

[ "def", "read_long_description", "(", "readme_file", ")", ":", "try", ":", "import", "pypandoc", "except", "(", "ImportError", ",", "OSError", ")", "as", "e", ":", "print", "(", "'No pypandoc or pandoc: %s'", "%", "(", "e", ",", ")", ")", "if", "is_py3", ":", "fh", "=", "open", "(", "readme_file", ",", "encoding", "=", "'utf-8'", ")", "else", ":", "fh", "=", "open", "(", "readme_file", ")", "long_description", "=", "fh", ".", "read", "(", ")", "fh", ".", "close", "(", ")", "return", "long_description", "else", ":", "return", "pypandoc", ".", "convert", "(", "readme_file", ",", "'rst'", ")" ]

[ "Read", "package", "long", "description", "from", "README", "file" ]

[ "def", "get_bin_edges_from_axis", "(", "axis", ")", "->", "np", ".", "ndarray", ":", "# Don't include over- or underflow bins", "bins", "=", "range", "(", "1", ",", "axis", ".", "GetNbins", "(", ")", "+", "1", ")", "# Bin edges", "bin_edges", "=", "np", ".", "empty", "(", "len", "(", "bins", ")", "+", "1", ")", "bin_edges", "[", ":", "-", "1", "]", "=", "[", "axis", ".", "GetBinLowEdge", "(", "i", ")", "for", "i", "in", "bins", "]", "bin_edges", "[", "-", "1", "]", "=", "axis", ".", "GetBinUpEdge", "(", "axis", ".", "GetNbins", "(", ")", ")", "return", "bin_edges" ]

[ "Get", "bin", "edges", "from", "a", "ROOT", "hist", "axis", "." ]

[ "def", "age_to_create_time", "(", "age", ",", "from_time", "=", "None", ")", ":", "if", "not", "age", ":", "return", "None", "if", "not", "from_time", ":", "from_time", "=", "dsub_util", ".", "replace_timezone", "(", "datetime", ".", "datetime", ".", "now", "(", ")", ",", "tzlocal", "(", ")", ")", "try", ":", "last_char", "=", "age", "[", "-", "1", "]", "if", "last_char", "==", "'s'", ":", "return", "from_time", "-", "datetime", ".", "timedelta", "(", "seconds", "=", "int", "(", "age", "[", ":", "-", "1", "]", ")", ")", "elif", "last_char", "==", "'m'", ":", "return", "from_time", "-", "datetime", ".", "timedelta", "(", "minutes", "=", "int", "(", "age", "[", ":", "-", "1", "]", ")", ")", "elif", "last_char", "==", "'h'", ":", "return", "from_time", "-", "datetime", ".", "timedelta", "(", "hours", "=", "int", "(", "age", "[", ":", "-", "1", "]", ")", ")", "elif", "last_char", "==", "'d'", ":", "return", "from_time", "-", "datetime", ".", "timedelta", "(", "days", "=", "int", "(", "age", "[", ":", "-", "1", "]", ")", ")", "elif", "last_char", "==", "'w'", ":", "return", "from_time", "-", "datetime", ".", "timedelta", "(", "weeks", "=", "int", "(", "age", "[", ":", "-", "1", "]", ")", ")", "else", ":", "# If no unit is given treat the age as seconds from epoch, otherwise apply", "# the correct time unit.", "return", "dsub_util", ".", "replace_timezone", "(", "datetime", ".", "datetime", ".", "utcfromtimestamp", "(", "int", "(", "age", ")", ")", ",", "pytz", ".", "utc", ")", "except", "(", "ValueError", ",", "OverflowError", ")", "as", "e", ":", "raise", "ValueError", "(", "'Unable to parse age string %s: %s'", "%", "(", "age", ",", "e", ")", ")" ]

[ "Compute", "the", "create", "time", "(", "UTC", ")", "for", "the", "list", "filter", "." ]

[ "def", "get_querystring", "(", "self", ")", ":", "to_remove", "=", "self", ".", "get_querystring_parameter_to_remove", "(", ")", "query_string", "=", "urlparse", "(", "self", ".", "request", ".", "get_full_path", "(", ")", ")", ".", "query", "query_dict", "=", "parse_qs", "(", "query_string", ".", "encode", "(", "'utf-8'", ")", ")", "for", "arg", "in", "to_remove", ":", "if", "arg", "in", "query_dict", ":", "del", "query_dict", "[", "arg", "]", "clean_query_string", "=", "urlencode", "(", "query_dict", ",", "doseq", "=", "True", ")", "return", "clean_query_string" ]

[ "Clean", "existing", "query", "string", "(", "GET", "parameters", ")", "by", "removing", "arguments", "that", "we", "don", "t", "want", "to", "preserve", "(", "sort", "parameter", "page", ")" ]

[ "def", "dup", "(", "self", ",", "position", ":", "int", ")", "->", "None", ":", "idx", "=", "-", "1", "*", "position", "try", ":", "self", ".", "push", "(", "self", ".", "values", "[", "idx", "]", ")", "except", "IndexError", ":", "raise", "InsufficientStack", "(", "\"Insufficient stack items for DUP{0}\"", ".", "format", "(", "position", ")", ")" ]

[ "Perform", "a", "DUP", "operation", "on", "the", "stack", "." ]

[ "def", "start_after", "(", "self", ",", "document_fields", ")", ":", "query", "=", "query_mod", ".", "Query", "(", "self", ")", "return", "query", ".", "start_after", "(", "document_fields", ")" ]

[ "Start", "query", "after", "a", "cursor", "with", "this", "collection", "as", "parent", "." ]

[ "def", "nextChainableJobGraph", "(", "jobGraph", ",", "jobStore", ")", ":", "#If no more jobs to run or services not finished, quit", "if", "len", "(", "jobGraph", ".", "stack", ")", "==", "0", "or", "len", "(", "jobGraph", ".", "services", ")", ">", "0", "or", "jobGraph", ".", "checkpoint", "!=", "None", ":", "logger", ".", "debug", "(", "\"Stopping running chain of jobs: length of stack: %s, services: %s, checkpoint: %s\"", ",", "len", "(", "jobGraph", ".", "stack", ")", ",", "len", "(", "jobGraph", ".", "services", ")", ",", "jobGraph", ".", "checkpoint", "!=", "None", ")", "return", "None", "#Get the next set of jobs to run", "jobs", "=", "jobGraph", ".", "stack", "[", "-", "1", "]", "assert", "len", "(", "jobs", ")", ">", "0", "#If there are 2 or more jobs to run in parallel we quit", "if", "len", "(", "jobs", ")", ">=", "2", ":", "logger", ".", "debug", "(", "\"No more jobs can run in series by this worker,\"", "\" it's got %i children\"", ",", "len", "(", "jobs", ")", "-", "1", ")", "return", "None", "#We check the requirements of the jobGraph to see if we can run it", "#within the current worker", "successorJobNode", "=", "jobs", "[", "0", "]", "if", "successorJobNode", ".", "memory", ">", "jobGraph", ".", "memory", ":", "logger", ".", "debug", "(", "\"We need more memory for the next job, so finishing\"", ")", "return", "None", "if", "successorJobNode", ".", "cores", ">", "jobGraph", ".", "cores", ":", "logger", ".", "debug", "(", "\"We need more cores for the next job, so finishing\"", ")", "return", "None", "if", "successorJobNode", ".", "disk", ">", "jobGraph", ".", "disk", ":", "logger", ".", "debug", "(", "\"We need more disk for the next job, so finishing\"", ")", "return", "None", "if", "successorJobNode", ".", "preemptable", "!=", "jobGraph", ".", "preemptable", ":", "logger", ".", "debug", "(", "\"Preemptability is different for the next job, returning to the leader\"", ")", "return", "None", "if", "successorJobNode", ".", "predecessorNumber", ">", "1", ":", "logger", ".", "debug", "(", "\"The jobGraph has multiple predecessors, we must return to the leader.\"", ")", "return", "None", "# Load the successor jobGraph", "successorJobGraph", "=", "jobStore", ".", "load", "(", "successorJobNode", ".", "jobStoreID", ")", "# Somewhat ugly, but check if job is a checkpoint job and quit if", "# so", "if", "successorJobGraph", ".", "command", ".", "startswith", "(", "\"_toil \"", ")", ":", "#Load the job", "successorJob", "=", "Job", ".", "_loadJob", "(", "successorJobGraph", ".", "command", ",", "jobStore", ")", "# Check it is not a checkpoint", "if", "successorJob", ".", "checkpoint", ":", "logger", ".", "debug", "(", "\"Next job is checkpoint, so finishing\"", ")", "return", "None", "# Made it through! This job is chainable.", "return", "successorJobGraph" ]

[ "Returns", "the", "next", "chainable", "jobGraph", "after", "this", "jobGraph", "if", "one", "exists", "or", "None", "if", "the", "chain", "must", "terminate", "." ]

[ "def", "formatError", "(", "self", ",", "test", ",", "err", ")", ":", "# logic flow copied from Capture.formatError", "test", ".", "capturedLogging", "=", "records", "=", "self", ".", "formatLogRecords", "(", ")", "if", "not", "records", ":", "return", "err", "ec", ",", "ev", ",", "tb", "=", "err", "return", "(", "ec", ",", "self", ".", "addCaptureToErr", "(", "ev", ",", "records", ")", ",", "tb", ")" ]

[ "Add", "captured", "log", "messages", "to", "error", "output", "." ]

[ "def", "loadfn", "(", "fname", ")", ":", "if", "(", "fnmatch", "(", "fname", ",", "\"*POSCAR*\"", ")", "or", "fnmatch", "(", "fname", ",", "\"*CONTCAR*\"", ")", "or", "\".cif\"", "in", "fname", ".", "lower", "(", ")", ")", "or", "fnmatch", "(", "fname", ",", "\"*.vasp\"", ")", ":", "return", "Structure", ".", "from_file", "(", "fname", ")", "elif", "fnmatch", "(", "fname", ",", "\"*vasprun*\"", ")", ":", "from", "pymatgen", ".", "io", ".", "vasp", "import", "Vasprun", "return", "Vasprun", "(", "fname", ")", "elif", "fnmatch", "(", "fname", ",", "\"*.json*\"", ")", ":", "from", "monty", ".", "serialization", "import", "loadfn", "return", "loadfn", "(", "fname", ")" ]

[ "Convenience", "method", "to", "perform", "quick", "loading", "of", "data", "from", "a", "filename", ".", "The", "type", "of", "object", "returned", "depends", "the", "file", "type", "." ]

[ "def", "ticket_comment_attachment_redact", "(", "self", ",", "ticket_id", ",", "comment_id", ",", "attachment_id", ",", "data", ",", "*", "*", "kwargs", ")", ":", "api_path", "=", "\"/api/v2/tickets/{ticket_id}/comments/{comment_id}/attachments/{attachment_id}/redact.json\"", "api_path", "=", "api_path", ".", "format", "(", "ticket_id", "=", "ticket_id", ",", "comment_id", "=", "comment_id", ",", "attachment_id", "=", "attachment_id", ")", "return", "self", ".", "call", "(", "api_path", ",", "method", "=", "\"PUT\"", ",", "data", "=", "data", ",", "*", "*", "kwargs", ")" ]

[ "https", ":", "//", "developer", ".", "zendesk", ".", "com", "/", "rest_api", "/", "docs", "/", "core", "/", "attachments#redact", "-", "comment", "-", "attachment" ]

[ "def", "radio_presets", "(", "self", ")", "->", "typing", ".", "Iterator", "[", "'FlyingUnit.RadioPresets'", "]", ":", "raise", "TypeError", "(", "'unit #{}: {}'", ".", "format", "(", "self", ".", "unit_id", ",", "self", ".", "unit_name", ")", ")" ]

[ "Returns", ":", "generator", "over", "unit", "radio", "presets" ]

[ "def", "write", "(", "self", ",", "s", ",", "level", "=", "0", ",", "color", "=", "None", ")", ":", "if", "level", ">", "self", ".", "level", ":", "return", "if", "self", ".", "timestamps", ":", "timestamp", "=", "time", ".", "strftime", "(", "u'%H:%M:%S '", ")", "else", ":", "timestamp", "=", "u''", "with", "lock", ":", "if", "self", ".", "context", ":", "self", ".", "stream", ".", "write", "(", "u'%s%s> '", "%", "(", "timestamp", ",", "self", ".", "context", ")", ")", "elif", "self", ".", "context", "is", "None", ":", "self", ".", "stream", ".", "write", "(", "u'%s%s> '", "%", "(", "timestamp", ",", "get_threadname", "(", ")", ")", ")", "self", ".", "stream", ".", "write", "(", "u'%s'", "%", "s", ",", "color", "=", "color", ")", "try", ":", "text_type", "=", "unicode", "except", "NameError", ":", "text_type", "=", "str", "self", ".", "stream", ".", "write", "(", "text_type", "(", "os", ".", "linesep", ")", ")", "self", ".", "stream", ".", "flush", "(", ")" ]

[ "Write", "message", "with", "indentation", "context", "and", "optional", "timestamp", "." ]

[ "def", "_to_dict", "(", "self", ")", ":", "_dict", "=", "{", "}", "if", "hasattr", "(", "self", ",", "'system'", ")", "and", "self", ".", "system", "is", "not", "None", ":", "_dict", "[", "'system'", "]", "=", "self", ".", "system", ".", "_to_dict", "(", ")", "return", "_dict" ]

[ "Return", "a", "json", "dictionary", "representing", "this", "model", "." ]

[ "def", "create_select_query", "(", "self", ",", "tokens", ")", ":", "if", "not", "tokens", "[", "Keyword", ".", "SELECT", "]", ":", "return", "None", "if", "not", "tokens", "[", "Keyword", ".", "FROM", "]", ":", "return", "None", "return", "SelectQuery", "(", "self", ".", "parse_keyword", "(", "Keyword", ".", "SELECT", ",", "tokens", ")", ",", "self", ".", "parse_keyword", "(", "Keyword", ".", "FROM", ",", "tokens", ")", ",", "where_stmt", "=", "self", ".", "parse_keyword", "(", "Keyword", ".", "WHERE", ",", "tokens", ")", ",", "limit_stmt", "=", "self", ".", "parse_keyword", "(", "Keyword", ".", "LIMIT", ",", "tokens", ")", ",", "group_by_stmt", "=", "self", ".", "parse_group", "(", "tokens", ")", ",", "duration", "=", "self", ".", "parsed_time_overlap", ".", "timespan_seconds", "(", ")", ",", "resolution", "=", "self", ".", "parsed_resolution", ",", "time_ranges", "=", "self", ".", "parsed_time", ",", "time_overlap", "=", "self", ".", "parsed_time_overlap", ",", "datapoints", "=", "self", ".", "parsed_datapoints", ")" ]

[ "Parse", "tokens", "of", "select", "query", ":", "param", "tokens", ":", "A", "list", "of", "InfluxDB", "query", "tokens" ]

[ "def", "drawPara", "(", "self", ",", "debug", "=", "0", ")", ":", "if", "self", ".", "debug", ":", "print", "(", "id", "(", "self", ")", ",", "\"drawPara\"", ",", "self", ".", "blPara", ".", "kind", ")", "#stash the key facts locally for speed", "canvas", "=", "self", ".", "canv", "style", "=", "self", ".", "style", "blPara", "=", "self", ".", "blPara", "lines", "=", "blPara", ".", "lines", "leading", "=", "style", ".", "leading", "autoLeading", "=", "getattr", "(", "self", ",", "'autoLeading'", ",", "getattr", "(", "style", ",", "'autoLeading'", ",", "''", ")", ")", "#work out the origin for line 1", "leftIndent", "=", "style", ".", "leftIndent", "cur_x", "=", "leftIndent", "if", "debug", ":", "bw", "=", "0.5", "bc", "=", "Color", "(", "1", ",", "1", ",", "0", ")", "bg", "=", "Color", "(", "0.9", ",", "0.9", ",", "0.9", ")", "else", ":", "bw", "=", "getattr", "(", "style", ",", "'borderWidth'", ",", "None", ")", "bc", "=", "getattr", "(", "style", ",", "'borderColor'", ",", "None", ")", "bg", "=", "style", ".", "backColor", "#if has a background or border, draw it", "if", "bg", "or", "(", "bc", "and", "bw", ")", ":", "canvas", ".", "saveState", "(", ")", "op", "=", "canvas", ".", "rect", "kwds", "=", "dict", "(", "fill", "=", "0", ",", "stroke", "=", "0", ")", "if", "bc", "and", "bw", ":", "canvas", ".", "setStrokeColor", "(", "bc", ")", "canvas", ".", "setLineWidth", "(", "bw", ")", "kwds", "[", "'stroke'", "]", "=", "1", "br", "=", "getattr", "(", "style", ",", "'borderRadius'", ",", "0", ")", "if", "br", "and", "not", "debug", ":", "op", "=", "canvas", ".", "roundRect", "kwds", "[", "'radius'", "]", "=", "br", "if", "bg", ":", "canvas", ".", "setFillColor", "(", "bg", ")", "kwds", "[", "'fill'", "]", "=", "1", "bp", "=", "getattr", "(", "style", ",", "'borderPadding'", ",", "0", ")", "op", "(", "leftIndent", "-", "bp", ",", "-", "bp", ",", "self", ".", "width", "-", "(", "leftIndent", "+", "style", ".", "rightIndent", ")", "+", "2", "*", "bp", ",", "self", ".", "height", "+", "2", "*", "bp", ",", "*", "*", "kwds", ")", "canvas", ".", "restoreState", "(", ")", "nLines", "=", "len", "(", "lines", ")", "bulletText", "=", "self", ".", "bulletText", "if", "nLines", ">", "0", ":", "_offsets", "=", "getattr", "(", "self", ",", "'_offsets'", ",", "[", "0", "]", ")", "_offsets", "+=", "(", "nLines", "-", "len", "(", "_offsets", ")", ")", "*", "[", "_offsets", "[", "-", "1", "]", "]", "canvas", ".", "saveState", "(", ")", "alignment", "=", "style", ".", "alignment", "offset", "=", "style", ".", "firstLineIndent", "+", "_offsets", "[", "0", "]", "lim", "=", "nLines", "-", "1", "noJustifyLast", "=", "not", "(", "hasattr", "(", "self", ",", "'_JustifyLast'", ")", "and", "self", ".", "_JustifyLast", ")", "if", "blPara", ".", "kind", "==", "0", ":", "if", "alignment", "==", "TA_LEFT", ":", "dpl", "=", "_leftDrawParaLine", "elif", "alignment", "==", "TA_CENTER", ":", "dpl", "=", "_centerDrawParaLine", "elif", "self", ".", "style", ".", "alignment", "==", "TA_RIGHT", ":", "dpl", "=", "_rightDrawParaLine", "elif", "self", ".", "style", ".", "alignment", "==", "TA_JUSTIFY", ":", "dpl", "=", "_justifyDrawParaLine", "f", "=", "blPara", "cur_y", "=", "self", ".", "height", "-", "getattr", "(", "f", ",", "'ascent'", ",", "f", ".", "fontSize", ")", "# TODO fix XPreformatted to remove this hack", "if", "bulletText", ":", "offset", "=", "_drawBullet", "(", "canvas", ",", "offset", ",", "cur_y", ",", "bulletText", ",", "style", ")", "#set up the font etc.", "canvas", ".", "setFillColor", "(", "f", ".", "textColor", ")", "tx", "=", "self", ".", "beginText", "(", "cur_x", ",", "cur_y", ")", "if", "autoLeading", "==", "'max'", ":", "leading", "=", "max", "(", "leading", ",", "LEADING_FACTOR", "*", "f", ".", "fontSize", ")", "elif", "autoLeading", "==", "'min'", ":", "leading", "=", "LEADING_FACTOR", "*", "f", ".", "fontSize", "#now the font for the rest of the paragraph", "tx", ".", "setFont", "(", "f", ".", "fontName", ",", "f", ".", "fontSize", ",", "leading", ")", "ws", "=", "getattr", "(", "tx", ",", "'_wordSpace'", ",", "0", ")", "t_off", "=", "dpl", "(", "tx", ",", "offset", ",", "ws", ",", "lines", "[", "0", "]", "[", "1", "]", ",", "noJustifyLast", "and", "nLines", "==", "1", ")", "if", "f", ".", "underline", "or", "f", ".", "link", "or", "f", ".", "strike", ":", "xs", "=", "tx", ".", "XtraState", "=", "ABag", "(", ")", "xs", ".", "cur_y", "=", "cur_y", "xs", ".", "f", "=", "f", "xs", ".", "style", "=", "style", "xs", ".", "lines", "=", "lines", "xs", ".", "underlines", "=", "[", "]", "xs", ".", "underlineColor", "=", "None", "# XXX Modified for XHTML2PDF", "xs", ".", "backgrounds", "=", "[", "]", "xs", ".", "backgroundColor", "=", "None", "xs", ".", "backgroundFontSize", "=", "None", "xs", ".", "strikes", "=", "[", "]", "xs", ".", "strikeColor", "=", "None", "# XXX Modified for XHTML2PDF", "xs", ".", "strikeFontSize", "=", "None", "xs", ".", "links", "=", "[", "]", "xs", ".", "link", "=", "f", ".", "link", "canvas", ".", "setStrokeColor", "(", "f", ".", "textColor", ")", "dx", "=", "t_off", "+", "leftIndent", "if", "dpl", "!=", "_justifyDrawParaLine", ":", "ws", "=", "0", "# XXX Never underline!", "underline", "=", "f", ".", "underline", "strike", "=", "f", ".", "strike", "link", "=", "f", ".", "link", "if", "underline", ":", "_do_under_line", "(", "0", ",", "dx", ",", "ws", ",", "tx", ")", "if", "strike", ":", "_do_under_line", "(", "0", ",", "dx", ",", "ws", ",", "tx", ",", "lm", "=", "0.125", ")", "if", "link", ":", "_do_link_line", "(", "0", ",", "dx", ",", "ws", ",", "tx", ")", "#now the middle of the paragraph, aligned with the left margin which is our origin.", "for", "i", "in", "six", ".", "moves", ".", "range", "(", "1", ",", "nLines", ")", ":", "ws", "=", "lines", "[", "i", "]", "[", "0", "]", "t_off", "=", "dpl", "(", "tx", ",", "_offsets", "[", "i", "]", ",", "ws", ",", "lines", "[", "i", "]", "[", "1", "]", ",", "noJustifyLast", "and", "i", "==", "lim", ")", "if", "dpl", "!=", "_justifyDrawParaLine", ":", "ws", "=", "0", "if", "underline", ":", "_do_under_line", "(", "i", ",", "t_off", "+", "leftIndent", ",", "ws", ",", "tx", ")", "if", "strike", ":", "_do_under_line", "(", "i", ",", "t_off", "+", "leftIndent", ",", "ws", ",", "tx", ",", "lm", "=", "0.125", ")", "if", "link", ":", "_do_link_line", "(", "i", ",", "t_off", "+", "leftIndent", ",", "ws", ",", "tx", ")", "else", ":", "for", "i", "in", "six", ".", "moves", ".", "range", "(", "1", ",", "nLines", ")", ":", "dpl", "(", "tx", ",", "_offsets", "[", "i", "]", ",", "lines", "[", "i", "]", "[", "0", "]", ",", "lines", "[", "i", "]", "[", "1", "]", ",", "noJustifyLast", "and", "i", "==", "lim", ")", "else", ":", "f", "=", "lines", "[", "0", "]", "cur_y", "=", "self", ".", "height", "-", "getattr", "(", "f", ",", "'ascent'", ",", "f", ".", "fontSize", ")", "# TODO fix XPreformatted to remove this hack", "# default?", "dpl", "=", "_leftDrawParaLineX", "if", "bulletText", ":", "offset", "=", "_drawBullet", "(", "canvas", ",", "offset", ",", "cur_y", ",", "bulletText", ",", "style", ")", "if", "alignment", "==", "TA_LEFT", ":", "dpl", "=", "_leftDrawParaLineX", "elif", "alignment", "==", "TA_CENTER", ":", "dpl", "=", "_centerDrawParaLineX", "elif", "self", ".", "style", ".", "alignment", "==", "TA_RIGHT", ":", "dpl", "=", "_rightDrawParaLineX", "elif", "self", ".", "style", ".", "alignment", "==", "TA_JUSTIFY", ":", "dpl", "=", "_justifyDrawParaLineX", "else", ":", "raise", "ValueError", "(", "\"bad align %s\"", "%", "repr", "(", "alignment", ")", ")", "#set up the font etc.", "tx", "=", "self", ".", "beginText", "(", "cur_x", ",", "cur_y", ")", "xs", "=", "tx", ".", "XtraState", "=", "ABag", "(", ")", "xs", ".", "textColor", "=", "None", "# XXX Modified for XHTML2PDF", "xs", ".", "backColor", "=", "None", "xs", ".", "rise", "=", "0", "xs", ".", "underline", "=", "0", "xs", ".", "underlines", "=", "[", "]", "xs", ".", "underlineColor", "=", "None", "# XXX Modified for XHTML2PDF", "xs", ".", "background", "=", "0", "xs", ".", "backgrounds", "=", "[", "]", "xs", ".", "backgroundColor", "=", "None", "xs", ".", "backgroundFontSize", "=", "None", "xs", ".", "strike", "=", "0", "xs", ".", "strikes", "=", "[", "]", "xs", ".", "strikeColor", "=", "None", "# XXX Modified for XHTML2PDF", "xs", ".", "strikeFontSize", "=", "None", "xs", ".", "links", "=", "[", "]", "xs", ".", "link", "=", "None", "xs", ".", "leading", "=", "style", ".", "leading", "xs", ".", "leftIndent", "=", "leftIndent", "tx", ".", "_leading", "=", "None", "tx", ".", "_olb", "=", "None", "xs", ".", "cur_y", "=", "cur_y", "xs", ".", "f", "=", "f", "xs", ".", "style", "=", "style", "xs", ".", "autoLeading", "=", "autoLeading", "tx", ".", "_fontname", ",", "tx", ".", "_fontsize", "=", "None", ",", "None", "dpl", "(", "tx", ",", "offset", ",", "lines", "[", "0", "]", ",", "noJustifyLast", "and", "nLines", "==", "1", ")", "_do_post_text", "(", "tx", ")", "#now the middle of the paragraph, aligned with the left margin which is our origin.", "for", "i", "in", "six", ".", "moves", ".", "range", "(", "1", ",", "nLines", ")", ":", "f", "=", "lines", "[", "i", "]", "dpl", "(", "tx", ",", "_offsets", "[", "i", "]", ",", "f", ",", "noJustifyLast", "and", "i", "==", "lim", ")", "_do_post_text", "(", "tx", ")", "canvas", ".", "drawText", "(", "tx", ")", "canvas", ".", "restoreState", "(", ")" ]

[ "Draws", "a", "paragraph", "according", "to", "the", "given", "style", ".", "Returns", "the", "final", "y", "position", "at", "the", "bottom", ".", "Not", "safe", "for", "paragraphs", "without", "spaces", "e", ".", "g", ".", "Japanese", ";", "wrapping", "algorithm", "will", "go", "infinite", "." ]

[ "def", "find_lib_path", "(", ")", ":", "curr_path", "=", "os", ".", "path", ".", "dirname", "(", "os", ".", "path", ".", "abspath", "(", "os", ".", "path", ".", "expanduser", "(", "__file__", ")", ")", ")", "# make pythonpack hack: copy this directory one level upper for setup.py", "dll_path", "=", "[", "curr_path", ",", "os", ".", "path", ".", "join", "(", "curr_path", ",", "'../../wrapper/'", ")", ",", "os", ".", "path", ".", "join", "(", "curr_path", ",", "'./wrapper/'", ")", "]", "if", "os", ".", "name", "==", "'nt'", ":", "if", "platform", ".", "architecture", "(", ")", "[", "0", "]", "==", "'64bit'", ":", "dll_path", ".", "append", "(", "os", ".", "path", ".", "join", "(", "curr_path", ",", "'../../windows/x64/Release/'", ")", ")", "# hack for pip installation when copy all parent source directory here", "dll_path", ".", "append", "(", "os", ".", "path", ".", "join", "(", "curr_path", ",", "'./windows/x64/Release/'", ")", ")", "else", ":", "dll_path", ".", "append", "(", "os", ".", "path", ".", "join", "(", "curr_path", ",", "'../../windows/Release/'", ")", ")", "# hack for pip installation when copy all parent source directory here", "dll_path", ".", "append", "(", "os", ".", "path", ".", "join", "(", "curr_path", ",", "'./windows/Release/'", ")", ")", "if", "os", ".", "name", "==", "'nt'", ":", "dll_path", "=", "[", "os", ".", "path", ".", "join", "(", "p", ",", "'xgboost_wrapper.dll'", ")", "for", "p", "in", "dll_path", "]", "else", ":", "dll_path", "=", "[", "os", ".", "path", ".", "join", "(", "p", ",", "'libxgboostwrapper.so'", ")", "for", "p", "in", "dll_path", "]", "lib_path", "=", "[", "p", "for", "p", "in", "dll_path", "if", "os", ".", "path", ".", "exists", "(", "p", ")", "and", "os", ".", "path", ".", "isfile", "(", "p", ")", "]", "#From github issues, most of installation errors come from machines w/o compilers", "if", "len", "(", "lib_path", ")", "==", "0", "and", "not", "os", ".", "environ", ".", "get", "(", "'XGBOOST_BUILD_DOC'", ",", "False", ")", ":", "raise", "XGBoostLibraryNotFound", "(", "'Cannot find XGBoost Libarary in the candicate path, '", "+", "'did you install compilers and run build.sh in root path?\\n'", "'List of candidates:\\n'", "+", "(", "'\\n'", ".", "join", "(", "dll_path", ")", ")", ")", "return", "lib_path" ]

[ "Load", "find", "the", "path", "to", "xgboost", "dynamic", "library", "files", "." ]

[ "def", "vnc_raspi_osmc", "(", ")", ":", "print", "(", "blue", "(", "'Install dependencies'", ")", ")", "install_packages", "(", "[", "'git'", ",", "'build-essential'", ",", "'rbp-userland-dev-osmc'", ",", "'libvncserver-dev'", ",", "'libconfig++-dev'", ",", "]", ")", "print", "(", "blue", "(", "'Build vnc server for raspberry pi using dispmanx '", "'(dispmanx_vnc)'", ")", ")", "checkup_git_repo_legacy", "(", "url", "=", "'https://github.com/patrikolausson/dispmanx_vnc.git'", ")", "run", "(", "'mkdir -p ~/repos'", ")", "run", "(", "'cd ~/repos/dispmanx_vnc && make'", ")", "print", "(", "blue", "(", "'set up dispmanx_vnc as a service'", ")", ")", "with", "warn_only", "(", ")", ":", "run", "(", "'sudo systemctl stop dispmanx_vncserver.service'", ")", "username", "=", "env", ".", "user", "builddir", "=", "flo", "(", "'/home/{username}/repos/dispmanx_vnc'", ")", "run", "(", "flo", "(", "'sudo cp {builddir}/dispmanx_vncserver /usr/bin'", ")", ")", "run", "(", "'sudo chmod +x /usr/bin/dispmanx_vncserver'", ")", "fabfile_data_dir", "=", "FABFILE_DATA_DIR", "put", "(", "'{fabfile_data_dir}/files/etc/dispmanx_vncserver.conf'", ",", "'/tmp/'", ")", "run", "(", "'sudo mv /tmp/dispmanx_vncserver.conf /etc/dispmanx_vncserver.conf'", ")", "put", "(", "'{fabfile_data_dir}/files/etc/systemd/system/dispmanx_vncserver.service'", ",", "'/tmp/'", ")", "run", "(", "'sudo mv /tmp/dispmanx_vncserver.service '", "'/etc/systemd/system/dispmanx_vncserver.service'", ")", "run", "(", "'sudo systemctl start dispmanx_vncserver.service'", ")", "run", "(", "'sudo systemctl enable dispmanx_vncserver.service'", ")", "run", "(", "'sudo systemctl daemon-reload'", ")" ]

[ "Install", "and", "configure", "dispmanx_vnc", "server", "on", "osmc", "(", "raspberry", "pi", ")", "." ]

[ "def", "get_step", "(", "self", ",", "grad", ")", ":", "if", "self", ".", "_momentum", "is", "None", ":", "self", ".", "_momentum", "=", "self", ".", "initial_accumulator_value", "*", "np", ".", "ones_like", "(", "grad", ")", "self", ".", "_momentum", "+=", "grad", "**", "2", "return", "self", ".", "learning_rate", "*", "grad", "/", "np", ".", "sqrt", "(", "self", ".", "_momentum", ")" ]

[ "Computes", "the", "step", "to", "take", "for", "the", "next", "gradient", "descent", "update", "." ]