Datasets:

---

kejian

/

codesearchnet-python-raw

like 1

[ "def", "parse_config_output", "(", "self", ",", "output", ")", ":", "regexp", "=", "re", ".", "compile", "(", "'^(config |edit |set |end$|next$)(.*)'", ")", "current_block", "=", "self", "if", "isinstance", "(", "output", ",", "py23_compat", ".", "string_types", ")", ":", "output", "=", "output", ".", "splitlines", "(", ")", "for", "line", "in", "output", ":", "if", "'uuid'", "in", "line", ":", "continue", "if", "'snmp-index'", "in", "line", ":", "continue", "line", "=", "line", ".", "strip", "(", ")", "result", "=", "regexp", ".", "match", "(", "line", ")", "if", "result", "is", "not", "None", ":", "action", "=", "result", ".", "group", "(", "1", ")", ".", "strip", "(", ")", "data", "=", "result", ".", "group", "(", "2", ")", ".", "strip", "(", ")", "if", "action", "==", "'config'", "or", "action", "==", "'edit'", ":", "data", "=", "data", ".", "replace", "(", "'\"'", ",", "''", ")", "if", "data", "not", "in", "current_block", ".", "get_block_names", "(", ")", ":", "config_block", "=", "FortiConfig", "(", "data", ",", "action", ",", "current_block", ")", "current_block", "[", "data", "]", "=", "config_block", "else", ":", "config_block", "=", "current_block", "[", "data", "]", "current_block", "=", "config_block", "elif", "action", "==", "'end'", "or", "action", "==", "'next'", ":", "current_block", "=", "current_block", ".", "get_parent", "(", ")", "elif", "action", "==", "'set'", ":", "split_data", "=", "data", ".", "split", "(", "' '", ")", "parameter", "=", "split_data", "[", "0", "]", "data", "=", "split_data", "[", "1", ":", "]", "current_block", ".", "set_param", "(", "parameter", ",", "' '", ".", "join", "(", "data", ")", ")" ]

[ "This", "method", "will", "parse", "a", "string", "containing", "FortiOS", "config", "and", "will", "load", "it", "into", "the", "current", ":", "class", ":", "~pyFG", ".", "forticonfig", ".", "FortiConfig", "object", "." ]

[ "def", "post_process", "(", "self", ",", "indices", ")", ":", "array", "=", "javabridge", ".", "call", "(", "self", ".", "jobject", ",", "\"postProcess\"", ",", "\"([I)[I\"", ",", "indices", ")", "if", "array", "is", "None", ":", "return", "None", "else", ":", "return", "javabridge", ".", "get_env", "(", ")", ".", "get_int_array_elements", "(", "array", ")" ]

[ "Post", "-", "processes", "the", "evaluator", "with", "the", "selected", "attribute", "indices", "." ]

[ "def", "get_params", "(", "self", ")", ":", "params", "=", "super", "(", ")", ".", "get_params", "(", ")", "params", ".", "update", "(", "{", "'knn'", ":", "self", ".", "knn", ",", "'decay'", ":", "self", ".", "decay", ",", "'bandwidth'", ":", "self", ".", "bandwidth", ",", "'bandwidth_scale'", ":", "self", ".", "bandwidth_scale", ",", "'distance'", ":", "self", ".", "distance", ",", "'precomputed'", ":", "self", ".", "precomputed", "}", ")", "return", "params" ]

[ "Get", "parameters", "from", "this", "object" ]

[ "def", "print_map", "(", "map_source", ",", "x", ",", "y", ",", "zoom", "=", "14", ",", "width", "=", "297", ",", "height", "=", "210", ",", "dpi", "=", "300", ",", "format", "=", "\"pdf\"", ")", ":", "bbox", "=", "get_print_bbox", "(", "x", ",", "y", ",", "zoom", ",", "width", ",", "height", ",", "dpi", ")", "tiles", "=", "[", "get_tiles", "(", "tile_layer", ",", "bbox", ")", "for", "tile_layer", "in", "map_source", ".", "layers", "if", "tile_layer", ".", "min_zoom", "<=", "zoom", "<=", "tile_layer", ".", "max_zoom", "]", "img", "=", "stitch_map", "(", "tiles", ",", "width", ",", "height", ",", "bbox", ",", "dpi", ")", "outfile", "=", "NamedTemporaryFile", "(", "delete", "=", "False", ")", "img", ".", "save", "(", "outfile", ",", "format", ",", "quality", "=", "100", ",", "dpi", "=", "(", "dpi", ",", "dpi", ")", ")", "outfile", ".", "close", "(", ")", "return", "outfile", ".", "name" ]

[ "Download", "map", "tiles", "and", "stitch", "them", "together", "in", "a", "single", "image", "ready", "for", "printing", "." ]

[ "def", "apply_perturbations", "(", "i", ",", "j", ",", "X", ",", "increase", ",", "theta", ",", "clip_min", ",", "clip_max", ")", ":", "warnings", ".", "warn", "(", "\"This function is dead code and will be removed on or after 2019-07-18\"", ")", "# perturb our input sample", "if", "increase", ":", "X", "[", "0", ",", "i", "]", "=", "np", ".", "minimum", "(", "clip_max", ",", "X", "[", "0", ",", "i", "]", "+", "theta", ")", "X", "[", "0", ",", "j", "]", "=", "np", ".", "minimum", "(", "clip_max", ",", "X", "[", "0", ",", "j", "]", "+", "theta", ")", "else", ":", "X", "[", "0", ",", "i", "]", "=", "np", ".", "maximum", "(", "clip_min", ",", "X", "[", "0", ",", "i", "]", "-", "theta", ")", "X", "[", "0", ",", "j", "]", "=", "np", ".", "maximum", "(", "clip_min", ",", "X", "[", "0", ",", "j", "]", "-", "theta", ")", "return", "X" ]

[ "TensorFlow", "implementation", "for", "apply", "perturbations", "to", "input", "features", "based", "on", "salency", "maps", ":", "param", "i", ":", "index", "of", "first", "selected", "feature", ":", "param", "j", ":", "index", "of", "second", "selected", "feature", ":", "param", "X", ":", "a", "matrix", "containing", "our", "input", "features", "for", "our", "sample", ":", "param", "increase", ":", "boolean", ";", "true", "if", "we", "are", "increasing", "pixels", "false", "otherwise", ":", "param", "theta", ":", "delta", "for", "each", "feature", "adjustment", ":", "param", "clip_min", ":", "mininum", "value", "for", "a", "feature", "in", "our", "sample", ":", "param", "clip_max", ":", "maximum", "value", "for", "a", "feature", "in", "our", "sample", ":", "return", ":", "a", "perturbed", "input", "feature", "matrix", "for", "a", "target", "class" ]

[ "def", "_check_value_recursively", "(", "key", ",", "val", ",", "haystack", ")", ":", "if", "isinstance", "(", "haystack", ",", "list", ")", ":", "return", "any", "(", "[", "_check_value_recursively", "(", "key", ",", "val", ",", "l", ")", "for", "l", "in", "haystack", "]", ")", "elif", "isinstance", "(", "haystack", ",", "dict", ")", ":", "if", "not", "key", "in", "haystack", ":", "return", "any", "(", "[", "_check_value_recursively", "(", "key", ",", "val", ",", "d", ")", "for", "k", ",", "d", "in", "haystack", ".", "items", "(", ")", "if", "isinstance", "(", "d", ",", "list", ")", "or", "isinstance", "(", "d", ",", "dict", ")", "]", ")", "else", ":", "return", "haystack", "[", "key", "]", "==", "val", "else", ":", "return", "False" ]

[ "Check", "if", "there", "is", "key", "_key_", "with", "value", "_val_", "in", "the", "given", "dictionary", ".", "..", "warning", ":", "This", "is", "geared", "at", "JSON", "dictionaries", "so", "some", "corner", "cases", "are", "ignored", "we", "assume", "all", "iterables", "are", "either", "arrays", "or", "dicts" ]

[ "def", "to_map_with_default", "(", "value", ",", "default_value", ")", ":", "result", "=", "RecursiveMapConverter", ".", "to_nullable_map", "(", "value", ")", "return", "result", "if", "result", "!=", "None", "else", "default_value" ]

[ "Converts", "value", "into", "map", "object", "or", "returns", "default", "when", "conversion", "is", "not", "possible" ]

[ "def", "get_order_columns_list", "(", "self", ",", "list_columns", "=", "None", ")", ":", "ret_lst", "=", "list", "(", ")", "list_columns", "=", "list_columns", "or", "self", ".", "get_columns_list", "(", ")", "for", "col_name", "in", "list_columns", ":", "if", "hasattr", "(", "self", ".", "obj", ",", "col_name", ")", ":", "if", "not", "hasattr", "(", "getattr", "(", "self", ".", "obj", ",", "col_name", ")", ",", "\"__call__\"", ")", ":", "ret_lst", ".", "append", "(", "col_name", ")", "else", ":", "ret_lst", ".", "append", "(", "col_name", ")", "return", "ret_lst" ]

[ "Returns", "the", "columns", "that", "can", "be", "ordered" ]

[ "def", "parse_type", "(", "parser", ")", ":", "# type: (Parser) -> Union[NamedType, NonNullType, ListType]", "start", "=", "parser", ".", "token", ".", "start", "if", "skip", "(", "parser", ",", "TokenKind", ".", "BRACKET_L", ")", ":", "ast_type", "=", "parse_type", "(", "parser", ")", "expect", "(", "parser", ",", "TokenKind", ".", "BRACKET_R", ")", "ast_type", "=", "ast", ".", "ListType", "(", "type", "=", "ast_type", ",", "loc", "=", "loc", "(", "parser", ",", "start", ")", ")", "# type: ignore", "else", ":", "ast_type", "=", "parse_named_type", "(", "parser", ")", "if", "skip", "(", "parser", ",", "TokenKind", ".", "BANG", ")", ":", "return", "ast", ".", "NonNullType", "(", "type", "=", "ast_type", ",", "loc", "=", "loc", "(", "parser", ",", "start", ")", ")", "return", "ast_type" ]

[ "Handles", "the", "Type", ":", "TypeName", "ListType", "and", "NonNullType", "parsing", "rules", "." ]

[ "def", "config_writer", "(", "self", ")", ":", "writer", "=", "self", ".", "repo", ".", "config_writer", "(", ")", "# clear our cache to assure we re-read the possibly changed configuration", "self", ".", "_clear_cache", "(", ")", "return", "SectionConstraint", "(", "writer", ",", "self", ".", "_config_section_name", "(", ")", ")" ]

[ ":", "return", ":", "GitConfigParser", "compatible", "object", "able", "to", "write", "options", "for", "this", "remote", ".", ":", "note", ":", "You", "can", "only", "own", "one", "writer", "at", "a", "time", "-", "delete", "it", "to", "release", "the", "configuration", "file", "and", "make", "it", "usable", "by", "others", "." ]

[ "def", "_nested_convert_to_tensor", "(", "struct", ",", "dtype", "=", "None", ",", "name", "=", "None", ")", ":", "if", "dtype", "is", "not", "None", "or", "not", "tf", ".", "nest", ".", "is_nested", "(", "struct", ")", ":", "return", "tf", ".", "convert_to_tensor", "(", "struct", ",", "dtype", "=", "dtype", ")", "if", "_maybe_convertible_to_tensor", "(", "struct", ")", ":", "try", ":", "# Try converting the structure wholesale.", "return", "tf", ".", "convert_to_tensor", "(", "value", "=", "struct", ",", "name", "=", "name", ")", "except", "(", "ValueError", ",", "TypeError", ")", ":", "# Unfortunately Eager/Graph mode don't agree on the error type.", "pass", "# Try converting all of its children.", "shallow_struct", "=", "_get_shallow_structure", "(", "struct", ")", "return", "nest", ".", "map_structure_up_to", "(", "shallow_struct", ",", "lambda", "s", ":", "_nested_convert_to_tensor", "(", "s", ",", "name", "=", "name", ")", ",", "struct", ")" ]

[ "Eagerly", "converts", "struct", "to", "Tensor", "recursing", "upon", "failure", "." ]

[ "def", "greylisting", "(", "data", ")", ":", "input_bam", "=", "data", ".", "get", "(", "\"work_bam_input\"", ",", "None", ")", "if", "not", "input_bam", ":", "logger", ".", "info", "(", "\"No input BAM file detected, skipping greylisting.\"", ")", "return", "None", "try", ":", "greylister", "=", "config_utils", ".", "get_program", "(", "\"chipseq-greylist\"", ",", "data", ")", "except", "config_utils", ".", "CmdNotFound", ":", "logger", ".", "info", "(", "\"No greylister found, skipping greylisting.\"", ")", "return", "None", "greylistdir", "=", "os", ".", "path", ".", "join", "(", "os", ".", "path", ".", "dirname", "(", "input_bam", ")", ",", "\"greylist\"", ")", "if", "os", ".", "path", ".", "exists", "(", "greylistdir", ")", ":", "return", "greylistdir", "cmd", "=", "\"{greylister} --outdir {txgreylistdir} {input_bam}\"", "message", "=", "\"Running greylisting on %s.\"", "%", "input_bam", "with", "file_transaction", "(", "greylistdir", ")", "as", "txgreylistdir", ":", "utils", ".", "safe_makedir", "(", "txgreylistdir", ")", "try", ":", "do", ".", "run", "(", "cmd", ".", "format", "(", "*", "*", "locals", "(", ")", ")", ",", "message", ")", "except", "subprocess", ".", "CalledProcessError", "as", "msg", ":", "if", "str", "(", "msg", ")", ".", "find", "(", "\"Cannot take a larger sample than population when 'replace=False'\"", ")", ">=", "0", ":", "logger", ".", "info", "(", "\"Skipping chipseq greylisting because of small sample size: %s\"", "%", "dd", ".", "get_sample_name", "(", "data", ")", ")", "return", "None", "return", "greylistdir" ]

[ "Run", "ChIP", "-", "seq", "greylisting" ]

[ "def", "get_varval_from_locals", "(", "key", ",", "locals_", ",", "strict", "=", "False", ")", ":", "assert", "isinstance", "(", "key", ",", "six", ".", "string_types", ")", ",", "'must have parsed key into a string already'", "if", "key", "not", "in", "locals_", ":", "dotpos", "=", "key", ".", "find", "(", "'.'", ")", "if", "dotpos", ">", "-", "1", ":", "key_", "=", "key", "[", ":", "dotpos", "]", "attrstr_", "=", "key", "[", "dotpos", ":", "]", "try", ":", "baseval", "=", "locals_", "[", "key_", "]", "# NOQA", "val", "=", "eval", "(", "'baseval'", "+", "attrstr_", ")", "except", "Exception", "as", "ex", ":", "if", "strict", ":", "raise", "val", "=", "ex", "else", ":", "raise", "AssertionError", "(", "'%s = NameError'", "%", "(", "key", ")", ")", "else", ":", "val", "=", "locals_", "[", "key", "]", "return", "val" ]

[ "Returns", "a", "variable", "value", "from", "locals", ".", "Different", "from", "locals", "()", "[", "varname", "]", "because", "get_varval_from_locals", "(", "varname", ".", "attribute", "locals", "()", ")", "is", "allowed" ]

[ "def", "annotate_filter", "(", "*", "*", "decargs", ")", ":", "def", "decorator", "(", "func", ")", ":", "\"\"\"Annotate events with entry and/or exit timestamps.\"\"\"", "def", "wrapper", "(", "event", ",", "*", "args", ",", "*", "*", "kwargs", ")", ":", "\"\"\"Add enter and exit annotations to the processed event.\"\"\"", "funcname", "=", "\":\"", ".", "join", "(", "[", "func", ".", "__module__", ",", "func", ".", "__name__", "]", ")", "enter_key", "=", "funcname", "+", "\"|enter\"", "annotate_event", "(", "event", ",", "enter_key", ",", "*", "*", "decargs", ")", "out", "=", "func", "(", "event", ",", "*", "args", ",", "*", "*", "kwargs", ")", "exit_key", "=", "funcname", "+", "\"|exit\"", "annotate_event", "(", "event", ",", "exit_key", ",", "*", "*", "decargs", ")", "return", "out", "return", "wrapper", "return", "decorator" ]

[ "Add", "input", "and", "output", "watermarks", "to", "filtered", "events", "." ]

[ "def", "resolve", "(", "self", ",", "value", "=", "None", ")", ":", "# If we still have an uninitialized matcher init it now", "if", "self", ".", "matcher", ":", "self", ".", "_init_matcher", "(", ")", "# Evaluate the current set of matchers forming the expression", "matcher", "=", "self", ".", "evaluate", "(", ")", "try", ":", "value", "=", "self", ".", "_transform", "(", "value", ")", "self", ".", "_assertion", "(", "matcher", ",", "value", ")", "except", "AssertionError", "as", "ex", ":", "# By re-raising here the exception we reset the traceback", "raise", "ex", "finally", ":", "# Reset the state of the object so we can use it again", "if", "self", ".", "deferred", ":", "self", ".", "reset", "(", ")" ]

[ "Resolve", "the", "current", "expression", "against", "the", "supplied", "value" ]

[ "def", "get_primary_key", "(", "self", ",", "table", ")", ":", "for", "column", "in", "self", ".", "get_schema", "(", "table", ")", ":", "if", "len", "(", "column", ")", ">", "3", "and", "'pri'", "in", "column", "[", "3", "]", ".", "lower", "(", ")", ":", "return", "column", "[", "0", "]" ]

[ "Retrieve", "the", "column", "which", "is", "the", "primary", "key", "for", "a", "table", "." ]

[ "def", "filter", "(", "self", ")", ":", "if", "isinstance", "(", "self", ".", "_filter", ",", "str", ")", ":", "return", "self", ".", "_decode_query", "(", "self", ".", "_filter", ")", "return", "self", ".", "_filter" ]

[ "Get", "the", "query", "of", "this", "Query", "." ]

[ "def", "convert_rename_autostart_entries_for_v0_95_3", "(", ")", ":", "old_autostart_file", "=", "Path", "(", "common", ".", "AUTOSTART_DIR", ")", "/", "\"autokey-gtk.desktop\"", "if", "old_autostart_file", ".", "exists", "(", ")", ":", "new_file_name", "=", "Path", "(", "common", ".", "AUTOSTART_DIR", ")", "/", "\"autokey.desktop\"", "_logger", ".", "info", "(", "\"Migration task: Found old autostart entry: '{}'. Rename to: '{}'\"", ".", "format", "(", "old_autostart_file", ",", "new_file_name", ")", ")", "old_autostart_file", ".", "rename", "(", "new_file_name", ")" ]

[ "In", "versions", "<", "=", "0", ".", "95", ".", "2", "the", "autostart", "option", "in", "autokey", "-", "gtk", "copied", "the", "default", "autokey", "-", "gtk", ".", "desktop", "file", "into", "$XDG_CONFIG_DIR", "/", "autostart", "(", "with", "minor", "unrelated", "modifications", ")", ".", "For", "versions", ">", "=", "0", ".", "95", ".", "3", "the", "autostart", "file", "is", "renamed", "to", "autokey", ".", "desktop", ".", "In", "0", ".", "95", ".", "3", "the", "autostart", "functionality", "is", "implemented", "for", "autokey", "-", "qt", ".", "Thus", "it", "becomes", "possible", "to", "have", "an", "autostart", "file", "for", "both", "GUIs", "in", "the", "autostart", "directory", "simultaneously", ".", "Because", "of", "the", "singleton", "nature", "of", "autokey", "this", "becomes", "an", "issue", "and", "race", "-", "conditions", "determine", "which", "GUI", "starts", "first", ".", "To", "prevent", "this", "both", "GUIs", "will", "share", "a", "single", "autokey", ".", "desktop", "autostart", "entry", "allowing", "only", "one", "GUI", "to", "be", "started", "during", "login", ".", "This", "allows", "for", "much", "simpler", "code", "." ]

[ "def", "parse_datetime_range", "(", "time_filter", ")", ":", "if", "not", "time_filter", ":", "time_filter", "=", "\"[* TO *]\"", "start", ",", "end", "=", "parse_solr_time_range_as_pair", "(", "time_filter", ")", "start", ",", "end", "=", "parse_datetime", "(", "start", ")", ",", "parse_datetime", "(", "end", ")", "return", "start", ",", "end" ]

[ "Parse", "the", "url", "param", "to", "python", "objects", ".", "From", "what", "time", "range", "to", "divide", "by", "a", ".", "time", ".", "gap", "into", "intervals", ".", "Defaults", "to", "q", ".", "time", "and", "otherwise", "90", "days", ".", "Validate", "in", "API", ":", "re", ".", "search", "(", "\\\\", "[", "(", ".", "*", ")", "TO", "(", ".", "*", ")", "\\\\", "]", "value", ")", ":", "param", "time_filter", ":", "[", "2013", "-", "03", "-", "01", "TO", "2013", "-", "05", "-", "01T00", ":", "00", ":", "00", "]", ":", "return", ":", "datetime", ".", "datetime", "(", "2013", "3", "1", "0", "0", ")", "datetime", ".", "datetime", "(", "2013", "5", "1", "0", "0", ")" ]

[ "def", "aks_versions_table_format", "(", "result", ")", ":", "# pylint: disable=import-error", "from", "jmespath", "import", "compile", "as", "compile_jmes", ",", "Options", "parsed", "=", "compile_jmes", "(", "\"\"\"orchestrators[].{\n kubernetesVersion: orchestratorVersion,\n upgrades: upgrades[].orchestratorVersion || [`None available`] | sort_versions(@) | join(`, `, @)\n }\"\"\"", ")", "# use ordered dicts so headers are predictable", "results", "=", "parsed", ".", "search", "(", "result", ",", "Options", "(", "dict_cls", "=", "OrderedDict", ",", "custom_functions", "=", "_custom_functions", "(", ")", ")", ")", "return", "sorted", "(", "results", ",", "key", "=", "lambda", "x", ":", "version_to_tuple", "(", "x", ".", "get", "(", "'kubernetesVersion'", ")", ")", ",", "reverse", "=", "True", ")" ]

[ "Format", "get", "-", "versions", "results", "as", "a", "summary", "for", "display", "with", "-", "o", "table", "." ]

[ "async", "def", "service_status", "(", "self", ",", "name", ")", ":", "return", "await", "self", ".", "send_command", "(", "OPERATIONS", ".", "CMD_QUERY_STATUS", ",", "{", "'name'", ":", "name", "}", ",", "MESSAGES", ".", "QueryStatusResponse", ",", "timeout", "=", "5.0", ")" ]

[ "Pull", "the", "current", "status", "of", "a", "service", "by", "name", "." ]

[ "def", "write_sequences_to_xlsx", "(", "path", ",", "seqs", ")", ":", "from", "openpyxl", "import", "Workbook", "wb", "=", "Workbook", "(", ")", "ws", "=", "wb", ".", "active", "for", "row", ",", "id", "in", "enumerate", "(", "seqs", ",", "1", ")", ":", "ws", ".", "cell", "(", "row", ",", "1", ")", ".", "value", "=", "id", "ws", ".", "cell", "(", "row", ",", "2", ")", ".", "value", "=", "seqs", "[", "id", "]", "wb", ".", "save", "(", "path", ")" ]

[ "Create", "a", "XLSX", "file", "listing", "the", "given", "sequences", "." ]

[ "def", "make_parser", "(", "self", ",", "ctx", ")", ":", "parser", "=", "OptionParser", "(", "ctx", ")", "parser", ".", "allow_interspersed_args", "=", "ctx", ".", "allow_interspersed_args", "parser", ".", "ignore_unknown_options", "=", "ctx", ".", "ignore_unknown_options", "for", "param", "in", "self", ".", "get_params", "(", "ctx", ")", ":", "param", ".", "add_to_parser", "(", "parser", ",", "ctx", ")", "return", "parser" ]

[ "Creates", "the", "underlying", "option", "parser", "for", "this", "command", "." ]

[ "def", "create_lease_object_from_subnet", "(", "self", ",", "subnet", ")", ":", "if", "'/'", "not", "in", "subnet", ":", "subnet", "=", "'{}/{}'", ".", "format", "(", "subnet", ",", "self", ".", "_cidr", ")", "try", ":", "if", "not", "self", ".", "is_leasable_subnet", "(", "subnet", ")", ":", "raise", "LagoSubnetLeaseOutOfRangeException", "(", "subnet", ",", "self", ".", "get_allowed_range", "(", ")", ")", "except", "AddrFormatError", ":", "raise", "LagoSubnetLeaseMalformedAddrException", "(", "subnet", ")", "return", "Lease", "(", "store_path", "=", "self", ".", "path", ",", "subnet", "=", "subnet", ")" ]

[ "Create", "a", "lease", "from", "ip", "in", "a", "dotted", "decimal", "format", "(", "for", "example", "192", ".", "168", ".", "200", ".", "0", "/", "24", ")", ".", "the", "_cidr", "will", "be", "added", "if", "not", "exist", "in", "subnet", "." ]

[ "def", "ajax_login_required", "(", "view_func", ")", ":", "@", "wraps", "(", "view_func", ",", "assigned", "=", "available_attrs", "(", "view_func", ")", ")", "def", "_wrapped_view", "(", "request", ",", "*", "args", ",", "*", "*", "kwargs", ")", ":", "if", "request", ".", "is_ajax", "(", ")", ":", "if", "request", ".", "user", ".", "is_authenticated", "(", ")", ":", "return", "view_func", "(", "request", ",", "*", "args", ",", "*", "*", "kwargs", ")", "else", ":", "response", "=", "http", ".", "HttpResponse", "(", ")", "response", "[", "'X-Django-Requires-Auth'", "]", "=", "True", "response", "[", "'X-Django-Login-Url'", "]", "=", "settings", ".", "LOGIN_URL", "return", "response", "else", ":", "return", "login_required", "(", "view_func", ")", "(", "request", ",", "*", "args", ",", "*", "*", "kwargs", ")", "return", "_wrapped_view" ]

[ "Handle", "non", "-", "authenticated", "users", "differently", "if", "it", "is", "an", "AJAX", "request", "." ]

[ "def", "save_webdriver_logs_by_type", "(", "self", ",", "log_type", ",", "test_name", ")", ":", "try", ":", "logs", "=", "self", ".", "driver_wrapper", ".", "driver", ".", "get_log", "(", "log_type", ")", "except", "Exception", ":", "return", "if", "len", "(", "logs", ")", ">", "0", ":", "log_file_name", "=", "'{}_{}.txt'", ".", "format", "(", "get_valid_filename", "(", "test_name", ")", ",", "log_type", ")", "log_file_name", "=", "os", ".", "path", ".", "join", "(", "DriverWrappersPool", ".", "logs_directory", ",", "log_file_name", ")", "with", "open", "(", "log_file_name", ",", "'a+'", ",", "encoding", "=", "'utf-8'", ")", "as", "log_file", ":", "driver_type", "=", "self", ".", "driver_wrapper", ".", "config", ".", "get", "(", "'Driver'", ",", "'type'", ")", "log_file", ".", "write", "(", "u\"\\n{} '{}' test logs with driver = {}\\n\\n\"", ".", "format", "(", "datetime", ".", "now", "(", ")", ",", "test_name", ",", "driver_type", ")", ")", "for", "entry", "in", "logs", ":", "timestamp", "=", "datetime", ".", "fromtimestamp", "(", "float", "(", "entry", "[", "'timestamp'", "]", ")", "/", "1000.", ")", ".", "strftime", "(", "'%Y-%m-%d %H:%M:%S.%f'", ")", "log_file", ".", "write", "(", "u'{}\\t{}\\t{}\\n'", ".", "format", "(", "timestamp", ",", "entry", "[", "'level'", "]", ",", "entry", "[", "'message'", "]", ".", "rstrip", "(", ")", ")", ")" ]

[ "Get", "webdriver", "logs", "of", "the", "specified", "type", "and", "write", "them", "to", "a", "log", "file" ]

[ "def", "__update_state", "(", "self", ")", ":", "# Only if the job was not in a terminal state.", "if", "self", ".", "_state", ".", "active", ":", "self", ".", "_state", "=", "self", ".", "__get_state_by_id", "(", "self", ".", "job_config", ".", "job_id", ")" ]

[ "Fetches", "most", "up", "to", "date", "state", "from", "db", "." ]

[ "def", "abort", "(", "http_status_code", ",", "exc", "=", "None", ",", "*", "*", "kwargs", ")", ":", "try", ":", "sanic", ".", "exceptions", ".", "abort", "(", "http_status_code", ",", "exc", ")", "except", "sanic", ".", "exceptions", ".", "SanicException", "as", "err", ":", "err", ".", "data", "=", "kwargs", "err", ".", "exc", "=", "exc", "raise", "err" ]

[ "Raise", "a", "HTTPException", "for", "the", "given", "http_status_code", ".", "Attach", "any", "keyword", "arguments", "to", "the", "exception", "for", "later", "processing", "." ]

[ "def", "hil_controls_encode", "(", "self", ",", "time_usec", ",", "roll_ailerons", ",", "pitch_elevator", ",", "yaw_rudder", ",", "throttle", ",", "aux1", ",", "aux2", ",", "aux3", ",", "aux4", ",", "mode", ",", "nav_mode", ")", ":", "return", "MAVLink_hil_controls_message", "(", "time_usec", ",", "roll_ailerons", ",", "pitch_elevator", ",", "yaw_rudder", ",", "throttle", ",", "aux1", ",", "aux2", ",", "aux3", ",", "aux4", ",", "mode", ",", "nav_mode", ")" ]

[ "Sent", "from", "autopilot", "to", "simulation", ".", "Hardware", "in", "the", "loop", "control", "outputs" ]

[ "def", "_preflight_check", "(", "desired", ",", "fromrepo", ",", "*", "*", "kwargs", ")", ":", "if", "'pkg.check_db'", "not", "in", "__salt__", ":", "return", "{", "}", "ret", "=", "{", "'suggest'", ":", "{", "}", ",", "'no_suggest'", ":", "[", "]", "}", "pkginfo", "=", "__salt__", "[", "'pkg.check_db'", "]", "(", "*", "list", "(", "desired", ".", "keys", "(", ")", ")", ",", "fromrepo", "=", "fromrepo", ",", "*", "*", "kwargs", ")", "for", "pkgname", "in", "pkginfo", ":", "if", "pkginfo", "[", "pkgname", "]", "[", "'found'", "]", "is", "False", ":", "if", "pkginfo", "[", "pkgname", "]", "[", "'suggestions'", "]", ":", "ret", "[", "'suggest'", "]", "[", "pkgname", "]", "=", "pkginfo", "[", "pkgname", "]", "[", "'suggestions'", "]", "else", ":", "ret", "[", "'no_suggest'", "]", ".", "append", "(", "pkgname", ")", "return", "ret" ]

[ "Perform", "platform", "-", "specific", "checks", "on", "desired", "packages" ]

[ "def", "unpack", "(", "self", ",", "fmt", ")", ":", "sfmt", "=", "compile_struct", "(", "fmt", ")", "size", "=", "sfmt", ".", "size", "offset", "=", "self", ".", "offset", "if", "self", ".", "data", ":", "avail", "=", "len", "(", "self", ".", "data", ")", "-", "offset", "else", ":", "avail", "=", "0", "if", "avail", "<", "size", ":", "raise", "UnpackException", "(", "fmt", ",", "size", ",", "avail", ")", "self", ".", "offset", "=", "offset", "+", "size", "return", "sfmt", ".", "unpack_from", "(", "self", ".", "data", ",", "offset", ")" ]

[ "unpacks", "the", "given", "fmt", "from", "the", "underlying", "buffer", "and", "returns", "the", "results", ".", "Will", "raise", "an", "UnpackException", "if", "there", "is", "not", "enough", "data", "to", "satisfy", "the", "fmt" ]

[ "def", "ProcessEvent", "(", "self", ",", "event", ",", "parser_chain", "=", "None", ",", "file_entry", "=", "None", ",", "query", "=", "None", ")", ":", "# TODO: rename this to event.parser_chain or equivalent.", "if", "not", "getattr", "(", "event", ",", "'parser'", ",", "None", ")", "and", "parser_chain", ":", "event", ".", "parser", "=", "parser_chain", "# TODO: deprecate text_prepend in favor of an event tag.", "if", "not", "getattr", "(", "event", ",", "'text_prepend'", ",", "None", ")", "and", "self", ".", "_text_prepend", ":", "event", ".", "text_prepend", "=", "self", ".", "_text_prepend", "if", "file_entry", "is", "None", ":", "file_entry", "=", "self", ".", "_file_entry", "display_name", "=", "None", "if", "file_entry", ":", "event", ".", "pathspec", "=", "file_entry", ".", "path_spec", "if", "not", "getattr", "(", "event", ",", "'filename'", ",", "None", ")", ":", "path_spec", "=", "getattr", "(", "file_entry", ",", "'path_spec'", ",", "None", ")", "event", ".", "filename", "=", "path_helper", ".", "PathHelper", ".", "GetRelativePathForPathSpec", "(", "path_spec", ",", "mount_path", "=", "self", ".", "_mount_path", ")", "if", "not", "display_name", ":", "# TODO: dfVFS refactor: move display name to output since the path", "# specification contains the full information.", "display_name", "=", "self", ".", "GetDisplayName", "(", "file_entry", ")", "stat_object", "=", "file_entry", ".", "GetStat", "(", ")", "inode_value", "=", "getattr", "(", "stat_object", ",", "'ino'", ",", "None", ")", "# TODO: refactor to ProcessEventData.", "# Note that we use getattr here since event can be either EventObject", "# or EventData.", "if", "getattr", "(", "event", ",", "'inode'", ",", "None", ")", "is", "None", "and", "inode_value", "is", "not", "None", ":", "event", ".", "inode", "=", "self", ".", "_GetInode", "(", "inode_value", ")", "if", "not", "getattr", "(", "event", ",", "'display_name'", ",", "None", ")", "and", "display_name", ":", "event", ".", "display_name", "=", "display_name", "if", "not", "getattr", "(", "event", ",", "'hostname'", ",", "None", ")", "and", "self", ".", "hostname", ":", "event", ".", "hostname", "=", "self", ".", "hostname", "if", "not", "getattr", "(", "event", ",", "'username'", ",", "None", ")", ":", "user_sid", "=", "getattr", "(", "event", ",", "'user_sid'", ",", "None", ")", "username", "=", "self", ".", "_knowledge_base", ".", "GetUsernameByIdentifier", "(", "user_sid", ")", "if", "username", ":", "event", ".", "username", "=", "username", "if", "not", "getattr", "(", "event", ",", "'query'", ",", "None", ")", "and", "query", ":", "event", ".", "query", "=", "query", "for", "attribute", ",", "value", "in", "iter", "(", "self", ".", "_extra_event_attributes", ".", "items", "(", ")", ")", ":", "if", "hasattr", "(", "event", ",", "attribute", ")", ":", "raise", "KeyError", "(", "'Event already has a value for {0:s}'", ".", "format", "(", "attribute", ")", ")", "setattr", "(", "event", ",", "attribute", ",", "value", ")" ]

[ "Processes", "an", "event", "before", "it", "written", "to", "the", "storage", "." ]

[ "def", "create_head", "(", "nf", ":", "int", ",", "nc", ":", "int", ",", "lin_ftrs", ":", "Optional", "[", "Collection", "[", "int", "]", "]", "=", "None", ",", "ps", ":", "Floats", "=", "0.5", ",", "concat_pool", ":", "bool", "=", "True", ",", "bn_final", ":", "bool", "=", "False", ")", ":", "lin_ftrs", "=", "[", "nf", ",", "512", ",", "nc", "]", "if", "lin_ftrs", "is", "None", "else", "[", "nf", "]", "+", "lin_ftrs", "+", "[", "nc", "]", "ps", "=", "listify", "(", "ps", ")", "if", "len", "(", "ps", ")", "==", "1", ":", "ps", "=", "[", "ps", "[", "0", "]", "/", "2", "]", "*", "(", "len", "(", "lin_ftrs", ")", "-", "2", ")", "+", "ps", "actns", "=", "[", "nn", ".", "ReLU", "(", "inplace", "=", "True", ")", "]", "*", "(", "len", "(", "lin_ftrs", ")", "-", "2", ")", "+", "[", "None", "]", "pool", "=", "AdaptiveConcatPool2d", "(", ")", "if", "concat_pool", "else", "nn", ".", "AdaptiveAvgPool2d", "(", "1", ")", "layers", "=", "[", "pool", ",", "Flatten", "(", ")", "]", "for", "ni", ",", "no", ",", "p", ",", "actn", "in", "zip", "(", "lin_ftrs", "[", ":", "-", "1", "]", ",", "lin_ftrs", "[", "1", ":", "]", ",", "ps", ",", "actns", ")", ":", "layers", "+=", "bn_drop_lin", "(", "ni", ",", "no", ",", "True", ",", "p", ",", "actn", ")", "if", "bn_final", ":", "layers", ".", "append", "(", "nn", ".", "BatchNorm1d", "(", "lin_ftrs", "[", "-", "1", "]", ",", "momentum", "=", "0.01", ")", ")", "return", "nn", ".", "Sequential", "(", "*", "layers", ")" ]

[ "Model", "head", "that", "takes", "nf", "features", "runs", "through", "lin_ftrs", "and", "about", "nc", "classes", "." ]

[ "def", "adjust_chunksize", "(", "self", ",", "current_chunksize", ",", "file_size", "=", "None", ")", ":", "chunksize", "=", "current_chunksize", "if", "file_size", "is", "not", "None", ":", "chunksize", "=", "self", ".", "_adjust_for_max_parts", "(", "chunksize", ",", "file_size", ")", "return", "self", ".", "_adjust_for_chunksize_limits", "(", "chunksize", ")" ]

[ "Get", "a", "chunksize", "close", "to", "current", "that", "fits", "within", "all", "S3", "limits", "." ]

[ "def", "start_server", "(", "self", ",", "protocol", "=", "'TCP'", ",", "port", "=", "5001", ",", "mss", "=", "None", ",", "window", "=", "None", ")", ":", "cmd", "=", "[", "'iperf'", ",", "'-s'", ",", "'-p'", ",", "str", "(", "port", ")", "]", "if", "not", "cmp", "(", "protocol", ",", "'UDP'", ")", ":", "cmd", ".", "append", "(", "'-u'", ")", "if", "mss", ":", "cmd", ".", "extend", "(", "[", "'-M'", ",", "str", "(", "mss", ")", "]", ")", "if", "window", ":", "cmd", ".", "extend", "(", "[", "'-w'", ",", "str", "(", "window", ")", "]", ")", "pid", "=", "utils", ".", "create_deamon", "(", "cmd", ")", "data", "=", "dict", "(", ")", "data", "[", "'pid'", "]", "=", "pid", "return", "data" ]

[ "iperf", "-", "s", "-", "D", "--", "mss", "mss" ]

[ "def", "set_tex_input_directory", "(", "self", ",", "tex_input_directory", ",", "latex_walker_init_args", "=", "None", ",", "strict_input", "=", "True", ")", ":", "self", ".", "tex_input_directory", "=", "tex_input_directory", "self", ".", "latex_walker_init_args", "=", "latex_walker_init_args", "if", "latex_walker_init_args", "else", "{", "}", "self", ".", "strict_input", "=", "strict_input", "if", "tex_input_directory", ":", "self", ".", "macro_dict", "[", "'input'", "]", "=", "MacroDef", "(", "'input'", ",", "lambda", "n", ":", "self", ".", "_callback_input", "(", "n", ")", ")", "self", ".", "macro_dict", "[", "'include'", "]", "=", "MacroDef", "(", "'include'", ",", "lambda", "n", ":", "self", ".", "_callback_input", "(", "n", ")", ")", "else", ":", "self", ".", "macro_dict", "[", "'input'", "]", "=", "MacroDef", "(", "'input'", ",", "discard", "=", "True", ")", "self", ".", "macro_dict", "[", "'include'", "]", "=", "MacroDef", "(", "'include'", ",", "discard", "=", "True", ")" ]

[ "Set", "where", "to", "look", "for", "input", "files", "when", "encountering", "the", "\\\\", "input", "or", "\\\\", "include", "macro", "." ]

[ "def", "read_digits", "(", "ctx", ",", "text", ")", ":", "def", "chunk", "(", "value", ",", "chunk_size", ")", ":", "return", "[", "value", "[", "i", ":", "i", "+", "chunk_size", "]", "for", "i", "in", "range", "(", "0", ",", "len", "(", "value", ")", ",", "chunk_size", ")", "]", "text", "=", "conversions", ".", "to_string", "(", "text", ",", "ctx", ")", ".", "strip", "(", ")", "if", "not", "text", ":", "return", "''", "# trim off the plus for phone numbers", "if", "text", "[", "0", "]", "==", "'+'", ":", "text", "=", "text", "[", "1", ":", "]", "length", "=", "len", "(", "text", ")", "# ssn", "if", "length", "==", "9", ":", "result", "=", "' '", ".", "join", "(", "text", "[", ":", "3", "]", ")", "result", "+=", "' , '", "+", "' '", ".", "join", "(", "text", "[", "3", ":", "5", "]", ")", "result", "+=", "' , '", "+", "' '", ".", "join", "(", "text", "[", "5", ":", "]", ")", "return", "result", "# triplets, most international phone numbers", "if", "length", "%", "3", "==", "0", "and", "length", ">", "3", ":", "chunks", "=", "chunk", "(", "text", ",", "3", ")", "return", "' '", ".", "join", "(", "','", ".", "join", "(", "chunks", ")", ")", "# quads, credit cards", "if", "length", "%", "4", "==", "0", ":", "chunks", "=", "chunk", "(", "text", ",", "4", ")", "return", "' '", ".", "join", "(", "','", ".", "join", "(", "chunks", ")", ")", "# otherwise, just put a comma between each number", "return", "','", ".", "join", "(", "text", ")" ]

[ "Formats", "digits", "in", "text", "for", "reading", "in", "TTS" ]

[ "def", "gather_callbacks", "(", "self", ",", "optimizer", ")", "->", "list", ":", "callbacks", "=", "[", "FrameTracker", "(", "self", ".", "total_frames", ")", ",", "TimeTracker", "(", ")", "]", "if", "self", ".", "scheduler_factory", "is", "not", "None", ":", "callbacks", ".", "append", "(", "self", ".", "scheduler_factory", ".", "instantiate", "(", "optimizer", ")", ")", "callbacks", ".", "extend", "(", "self", ".", "callbacks", ")", "callbacks", ".", "extend", "(", "self", ".", "storage", ".", "streaming_callbacks", "(", ")", ")", "return", "callbacks" ]

[ "Gather", "all", "the", "callbacks", "to", "be", "used", "in", "this", "training", "run" ]

[ "async", "def", "get_guild_count", "(", "self", ",", "bot_id", ":", "int", "=", "None", ")", ":", "if", "bot_id", "is", "None", ":", "bot_id", "=", "self", ".", "bot_id", "return", "await", "self", ".", "http", ".", "get_guild_count", "(", "bot_id", ")" ]

[ "This", "function", "is", "a", "coroutine", "." ]

[ "def", "unpack_from", "(", "self", ",", "buff", ",", "offset", "=", "0", ")", ":", "return", "self", ".", "_create", "(", "super", "(", "NamedStruct", ",", "self", ")", ".", "unpack_from", "(", "buff", ",", "offset", ")", ")" ]

[ "Read", "bytes", "from", "a", "buffer", "and", "return", "as", "a", "namedtuple", "." ]

[ "def", "register_scenario", "(", "self", ",", "scenario_name", ",", "handler", ")", ":", "if", "scenario_name", "in", "self", ".", "_known_scenarios", ":", "raise", "ArgumentError", "(", "\"Attempted to add the same scenario name twice\"", ",", "scenario_name", "=", "scenario_name", ",", "previous_handler", "=", "self", ".", "_known_scenarios", "[", "scenario_name", "]", ")", "self", ".", "_known_scenarios", "[", "scenario_name", "]", "=", "handler" ]

[ "Register", "a", "scenario", "handler", "for", "this", "object", "." ]

[ "def", "_updateTabStopWidth", "(", "self", ")", ":", "self", ".", "setTabStopWidth", "(", "self", ".", "fontMetrics", "(", ")", ".", "width", "(", "' '", "*", "self", ".", "_indenter", ".", "width", ")", ")" ]

[ "Update", "tabstop", "width", "after", "font", "or", "indentation", "changed" ]

[ "def", "download_file", "(", "self", ",", "file_id", ",", "dest", ")", ":", "f", "=", "self", ".", "getFile", "(", "file_id", ")", "try", ":", "d", "=", "dest", "if", "_isfile", "(", "dest", ")", "else", "open", "(", "dest", ",", "'wb'", ")", "r", "=", "api", ".", "download", "(", "(", "self", ".", "_token", ",", "f", "[", "'file_path'", "]", ")", ",", "preload_content", "=", "False", ")", "while", "1", ":", "data", "=", "r", ".", "read", "(", "self", ".", "_file_chunk_size", ")", "if", "not", "data", ":", "break", "d", ".", "write", "(", "data", ")", "finally", ":", "if", "not", "_isfile", "(", "dest", ")", "and", "'d'", "in", "locals", "(", ")", ":", "d", ".", "close", "(", ")", "if", "'r'", "in", "locals", "(", ")", ":", "r", ".", "release_conn", "(", ")" ]

[ "Download", "a", "file", "to", "local", "disk", "." ]

[ "def", "tags_uuids", "(", "self", ",", "uuids", ",", "archiver", "=", "\"\"", ",", "timeout", "=", "DEFAULT_TIMEOUT", ")", ":", "if", "not", "isinstance", "(", "uuids", ",", "list", ")", ":", "uuids", "=", "[", "uuids", "]", "where", "=", "\" or \"", ".", "join", "(", "[", "'uuid = \"{0}\"'", ".", "format", "(", "uuid", ")", "for", "uuid", "in", "uuids", "]", ")", "return", "self", ".", "query", "(", "\"select * where {0}\"", ".", "format", "(", "where", ")", ",", "archiver", ",", "timeout", ")", ".", "get", "(", "'metadata'", ",", "{", "}", ")" ]

[ "Retrieves", "tags", "for", "all", "streams", "with", "the", "provided", "UUIDs" ]

[ "def", "deferFunction", "(", "self", ",", "callable", ")", ":", "self", ".", "_deferredFunctions", ".", "append", "(", "(", "callable", ",", "self", ".", "scopeStack", "[", ":", "]", ",", "self", ".", "offset", ")", ")" ]

[ "Schedule", "a", "function", "handler", "to", "be", "called", "just", "before", "completion", "." ]

[ "def", "netmiko_fun", "(", "fun", ",", "*", "args", ",", "*", "*", "kwargs", ")", ":", "if", "'netmiko.'", "not", "in", "fun", ":", "fun", "=", "'netmiko.{fun}'", ".", "format", "(", "fun", "=", "fun", ")", "netmiko_kwargs", "=", "netmiko_args", "(", ")", "kwargs", ".", "update", "(", "netmiko_kwargs", ")", "return", "__salt__", "[", "fun", "]", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "..", "versionadded", "::", "2019", ".", "2", ".", "0" ]

[ "def", "properties", "(", "self", ")", ":", "properties", "=", "{", "'id'", ":", "self", ".", "_id", "}", "if", "self", ".", "_name", "is", "not", "None", ":", "properties", "[", "'name'", "]", "=", "self", ".", "_name", "return", "properties" ]

[ "All", "compartment", "properties", "as", "a", "dict", "." ]

[ "def", "stop_listener_thread", "(", "self", ")", ":", "# when stopping, `kill` will cause the `self.api.sync` call in _sync", "# to raise a connection error. This flag will ensure it exits gracefully then", "self", ".", "should_listen", "=", "False", "if", "self", ".", "sync_thread", ":", "self", ".", "sync_thread", ".", "kill", "(", ")", "self", ".", "sync_thread", ".", "get", "(", ")", "if", "self", ".", "_handle_thread", "is", "not", "None", ":", "self", ".", "_handle_thread", ".", "get", "(", ")", "self", ".", "sync_thread", "=", "None", "self", ".", "_handle_thread", "=", "None" ]

[ "Kills", "sync_thread", "greenlet", "before", "joining", "it" ]

[ "def", "extract_child_models_of_state", "(", "state_m", ",", "new_state_class", ")", ":", "# check if root state and which type of state", "assert", "isinstance", "(", "state_m", ",", "StateModel", ")", "assert", "issubclass", "(", "new_state_class", ",", "State", ")", "orig_state", "=", "state_m", ".", "state", "# only here to get the input parameter of the Core-function", "current_state_is_container", "=", "isinstance", "(", "orig_state", ",", "ContainerState", ")", "new_state_is_container", "=", "issubclass", "(", "new_state_class", ",", "ContainerState", ")", "# define which model references to hold for new state", "required_model_properties", "=", "[", "'input_data_ports'", ",", "'output_data_ports'", ",", "'outcomes'", ",", "'income'", "]", "obsolete_model_properties", "=", "[", "]", "if", "current_state_is_container", "and", "new_state_is_container", ":", "# hold some additional references", "# transition are removed when changing the state type, thus do not copy them", "required_model_properties", ".", "extend", "(", "[", "'states'", ",", "'data_flows'", ",", "'scoped_variables'", "]", ")", "obsolete_model_properties", ".", "append", "(", "'transitions'", ")", "elif", "current_state_is_container", ":", "obsolete_model_properties", ".", "extend", "(", "[", "'states'", ",", "'transitions'", ",", "'data_flows'", ",", "'scoped_variables'", "]", ")", "def", "get_element_list", "(", "state_m", ",", "prop_name", ")", ":", "if", "prop_name", "==", "'income'", ":", "return", "[", "state_m", ".", "income", "]", "wrapper", "=", "getattr", "(", "state_m", ",", "prop_name", ")", "# ._obj is needed as gaphas wraps observable lists and dicts into a gaphas.support.ObsWrapper", "list_or_dict", "=", "wrapper", ".", "_obj", "if", "isinstance", "(", "list_or_dict", ",", "list", ")", ":", "return", "list_or_dict", "[", ":", "]", "# copy list", "return", "list", "(", "list_or_dict", ".", "values", "(", ")", ")", "# dict", "required_child_models", "=", "{", "}", "for", "prop_name", "in", "required_model_properties", ":", "required_child_models", "[", "prop_name", "]", "=", "get_element_list", "(", "state_m", ",", "prop_name", ")", "obsolete_child_models", "=", "{", "}", "for", "prop_name", "in", "obsolete_model_properties", ":", "obsolete_child_models", "[", "prop_name", "]", "=", "get_element_list", "(", "state_m", ",", "prop_name", ")", "# Special handling of BarrierState, which includes the DeciderState that always becomes obsolete", "if", "isinstance", "(", "state_m", ",", "ContainerStateModel", ")", ":", "decider_state_m", "=", "state_m", ".", "states", ".", "get", "(", "UNIQUE_DECIDER_STATE_ID", ",", "None", ")", "if", "decider_state_m", ":", "if", "new_state_is_container", ":", "required_child_models", "[", "'states'", "]", ".", "remove", "(", "decider_state_m", ")", "obsolete_child_models", "[", "'states'", "]", "=", "[", "decider_state_m", "]", "return", "required_child_models", ",", "obsolete_child_models" ]

[ "Retrieve", "child", "models", "of", "state", "model" ]

[ "def", "save", "(", "self", ",", "items", ")", ":", "rows", "=", "[", "]", "indx", "=", "self", ".", "indx", "size", "=", "0", "tick", "=", "s_common", ".", "now", "(", ")", "for", "item", "in", "items", ":", "byts", "=", "s_msgpack", ".", "en", "(", "item", ")", "size", "+=", "len", "(", "byts", ")", "lkey", "=", "s_common", ".", "int64en", "(", "indx", ")", "indx", "+=", "1", "rows", ".", "append", "(", "(", "lkey", ",", "byts", ")", ")", "self", ".", "slab", ".", "putmulti", "(", "rows", ",", "append", "=", "True", ",", "db", "=", "self", ".", "db", ")", "took", "=", "s_common", ".", "now", "(", ")", "-", "tick", "origindx", "=", "self", ".", "indx", "self", ".", "indx", "=", "indx", "return", "{", "'indx'", ":", "indx", ",", "'size'", ":", "size", ",", "'count'", ":", "len", "(", "items", ")", ",", "'time'", ":", "tick", ",", "'took'", ":", "took", "}", "return", "origindx" ]

[ "Save", "a", "series", "of", "items", "to", "a", "sequence", "." ]

[ "def", "_generate_full_recipe_message", "(", "self", ",", "destination", ",", "message", ",", "add_path_step", ")", ":", "if", "add_path_step", "and", "self", ".", "recipe_pointer", ":", "recipe_path", "=", "self", ".", "recipe_path", "+", "[", "self", ".", "recipe_pointer", "]", "else", ":", "recipe_path", "=", "self", ".", "recipe_path", "return", "{", "\"environment\"", ":", "self", ".", "environment", ",", "\"payload\"", ":", "message", ",", "\"recipe\"", ":", "self", ".", "recipe", ".", "recipe", ",", "\"recipe-path\"", ":", "recipe_path", ",", "\"recipe-pointer\"", ":", "destination", ",", "}" ]

[ "Factory", "function", "to", "generate", "independent", "message", "objects", "for", "downstream", "recipients", "with", "different", "destinations", "." ]

[ "def", "get_connection", "(", "self", ",", "command", ",", "args", "=", "(", ")", ")", ":", "# TODO: find a better way to determine if connection is free", "# and not havily used.", "command", "=", "command", ".", "upper", "(", ")", ".", "strip", "(", ")", "is_pubsub", "=", "command", "in", "_PUBSUB_COMMANDS", "if", "is_pubsub", "and", "self", ".", "_pubsub_conn", ":", "if", "not", "self", ".", "_pubsub_conn", ".", "closed", ":", "return", "self", ".", "_pubsub_conn", ",", "self", ".", "_pubsub_conn", ".", "address", "self", ".", "_pubsub_conn", "=", "None", "for", "i", "in", "range", "(", "self", ".", "freesize", ")", ":", "conn", "=", "self", ".", "_pool", "[", "0", "]", "self", ".", "_pool", ".", "rotate", "(", "1", ")", "if", "conn", ".", "closed", ":", "# or conn._waiters: (eg: busy connection)", "continue", "if", "conn", ".", "in_pubsub", ":", "continue", "if", "is_pubsub", ":", "self", ".", "_pubsub_conn", "=", "conn", "self", ".", "_pool", ".", "remove", "(", "conn", ")", "self", ".", "_used", ".", "add", "(", "conn", ")", "return", "conn", ",", "conn", ".", "address", "return", "None", ",", "self", ".", "_address" ]

[ "Get", "free", "connection", "from", "pool", "." ]

[ "def", "show", "(", "fig", "=", "None", ",", "path", "=", "'_map.html'", ",", "*", "*", "kwargs", ")", ":", "import", "webbrowser", "fullpath", "=", "os", ".", "path", ".", "abspath", "(", "path", ")", "with", "open", "(", "fullpath", ",", "'w'", ")", "as", "f", ":", "save_html", "(", "fig", ",", "fileobj", "=", "f", ",", "*", "*", "kwargs", ")", "webbrowser", ".", "open", "(", "'file://'", "+", "fullpath", ")" ]

[ "Convert", "a", "Matplotlib", "Figure", "to", "a", "Leaflet", "map", ".", "Open", "in", "a", "browser" ]

[ "def", "get", "(", "self", ",", "key", ",", "*", "*", "kwargs", ")", ":", "range_response", "=", "self", ".", "get_response", "(", "key", ",", "*", "*", "kwargs", ")", "if", "range_response", ".", "count", "<", "1", ":", "return", "None", ",", "None", "else", ":", "kv", "=", "range_response", ".", "kvs", ".", "pop", "(", ")", "return", "kv", ".", "value", ",", "KVMetadata", "(", "kv", ",", "range_response", ".", "header", ")" ]

[ "Get", "the", "value", "of", "a", "key", "from", "etcd", "." ]

[ "def", "_has_homonym_in_upper_function_scope", "(", "self", ",", "node", ",", "index", ")", ":", "for", "_consumer", "in", "self", ".", "_to_consume", "[", "index", "-", "1", ":", ":", "-", "1", "]", ":", "if", "_consumer", ".", "scope_type", "==", "\"function\"", "and", "node", ".", "name", "in", "_consumer", ".", "to_consume", ":", "return", "True", "return", "False" ]

[ "Return", "True", "if", "there", "is", "a", "node", "with", "the", "same", "name", "in", "the", "to_consume", "dict", "of", "an", "upper", "scope", "and", "if", "that", "scope", "is", "a", "function" ]

[ "def", "deserialize_skycoord", "(", "d", ")", ":", "if", "'distance'", "in", "d", ":", "args", "=", "(", "d", "[", "'lon'", "]", ",", "d", "[", "'lat'", "]", ",", "d", "[", "'distance'", "]", ")", "else", ":", "args", "=", "(", "d", "[", "'lon'", "]", ",", "d", "[", "'lat'", "]", ")", "return", "coords", ".", "SkyCoord", "(", "*", "args", ",", "frame", "=", "d", "[", "'frame'", "]", ",", "representation", "=", "'spherical'", ")" ]

[ "Deserializes", "a", "JSONified", ":", "obj", ":", "astropy", ".", "coordinates", ".", "SkyCoord", "." ]

[ "def", "get_xml", "(", "connection", ",", "table_names", "=", "None", ")", ":", "ligo_lw", "=", "ligolw", ".", "LIGO_LW", "(", ")", "if", "table_names", "is", "None", ":", "table_names", "=", "get_table_names", "(", "connection", ")", "for", "table_name", "in", "table_names", ":", "# build the table document tree. copied from", "# lsctables.New()", "try", ":", "cls", "=", "TableByName", "[", "table_name", "]", "except", "KeyError", ":", "cls", "=", "DBTable", "table_elem", "=", "cls", "(", "AttributesImpl", "(", "{", "u\"Name\"", ":", "u\"%s:table\"", "%", "table_name", "}", ")", ",", "connection", "=", "connection", ")", "for", "column_name", ",", "column_type", "in", "get_column_info", "(", "connection", ",", "table_elem", ".", "Name", ")", ":", "if", "table_elem", ".", "validcolumns", "is", "not", "None", ":", "# use the pre-defined column type", "column_type", "=", "table_elem", ".", "validcolumns", "[", "column_name", "]", "else", ":", "# guess the column type", "column_type", "=", "ligolwtypes", ".", "FromSQLiteType", "[", "column_type", "]", "table_elem", ".", "appendChild", "(", "table", ".", "Column", "(", "AttributesImpl", "(", "{", "u\"Name\"", ":", "u\"%s:%s\"", "%", "(", "table_name", ",", "column_name", ")", ",", "u\"Type\"", ":", "column_type", "}", ")", ")", ")", "table_elem", ".", "_end_of_columns", "(", ")", "table_elem", ".", "appendChild", "(", "table", ".", "TableStream", "(", "AttributesImpl", "(", "{", "u\"Name\"", ":", "u\"%s:table\"", "%", "table_name", ",", "u\"Delimiter\"", ":", "table", ".", "TableStream", ".", "Delimiter", ".", "default", ",", "u\"Type\"", ":", "table", ".", "TableStream", ".", "Type", ".", "default", "}", ")", ")", ")", "ligo_lw", ".", "appendChild", "(", "table_elem", ")", "return", "ligo_lw" ]

[ "Construct", "an", "XML", "document", "tree", "wrapping", "around", "the", "contents", "of", "the", "database", ".", "On", "success", "the", "return", "value", "is", "a", "ligolw", ".", "LIGO_LW", "element", "containing", "the", "tables", "as", "children", ".", "Arguments", "are", "a", "connection", "to", "to", "a", "database", "and", "an", "optional", "list", "of", "table", "names", "to", "dump", ".", "If", "table_names", "is", "not", "provided", "the", "set", "is", "obtained", "from", "get_table_names", "()" ]

[ "def", "update_from_item", "(", "self", ",", "item", ")", ":", "if", "not", "self", ".", "is_time_module", ":", "# correct the output", "# Restore the name/instance.", "item", "[", "\"name\"", "]", "=", "self", ".", "name", "item", "[", "\"instance\"", "]", "=", "self", ".", "instance", "# change color good/bad is set specifically for module", "if", "\"color\"", "in", "item", "and", "item", "[", "\"color\"", "]", "in", "self", ".", "color_map", ":", "item", "[", "\"color\"", "]", "=", "self", ".", "color_map", "[", "item", "[", "\"color\"", "]", "]", "# have we updated?", "is_updated", "=", "self", ".", "item", "!=", "item", "self", ".", "item", "=", "item", "else", ":", "# If no timezone or a minute has passed update timezone", "t", "=", "time", "(", ")", "if", "self", ".", "time_zone_check_due", "<", "t", ":", "# If we are late for our timezone update then schedule the next", "# update to happen when we next get new data from i3status", "interval", "=", "self", ".", "i3status", ".", "update_interval", "if", "not", "self", ".", "set_time_zone", "(", "item", ")", ":", "# we had an issue with an invalid time zone probably due to", "# suspending. re check the time zone when we next can.", "self", ".", "time_zone_check_due", "=", "0", "elif", "self", ".", "time_zone_check_due", "and", "(", "t", "-", "self", ".", "time_zone_check_due", ">", "5", "+", "interval", ")", ":", "self", ".", "time_zone_check_due", "=", "0", "else", ":", "# Check again in 30 mins. We do this in case the timezone", "# used has switched to/from summer time", "self", ".", "time_zone_check_due", "=", "(", "(", "int", "(", "t", ")", "//", "1800", ")", "*", "1800", ")", "+", "1800", "if", "not", "self", ".", "time_started", ":", "self", ".", "time_started", "=", "True", "self", ".", "i3status", ".", "py3_wrapper", ".", "timeout_queue_add", "(", "self", ")", "is_updated", "=", "False", "# update time to be shown", "return", "is_updated" ]

[ "Update", "from", "i3status", "output", ".", "returns", "if", "item", "has", "changed", "." ]

[ "def", "HSTsync", "(", "sim", ",", "cam", ",", "verbose", ")", ":", "try", ":", "if", "isinstance", "(", "sim", ".", "startutc", ",", "datetime", ")", ":", "reqStart", "=", "sim", ".", "startutc", ".", "timestamp", "(", ")", "reqStop", "=", "sim", ".", "stoputc", ".", "timestamp", "(", ")", "elif", "isinstance", "(", "sim", ".", "startutc", ",", "(", "float", ",", "int", ")", ")", ":", "# ut1_unix", "reqStart", "=", "sim", ".", "startutc", "reqStop", "=", "sim", ".", "stoputc", "else", ":", "raise", "TypeError", "(", "'unknown time request format'", ")", "except", "AttributeError", ":", "# no specified start,stop, but is there a specifed time list?", "try", ":", "treqlist", "=", "atleast_1d", "(", "sim", ".", "treqlist", ")", "if", "isinstance", "(", "treqlist", "[", "0", "]", ",", "datetime", ")", ":", "treqlist", "=", "array", "(", "[", "t", ".", "timestamp", "(", ")", "for", "t", "in", "treqlist", "]", ")", "elif", "isinstance", "(", "treqlist", "[", "0", "]", ",", "(", "float", ",", "int", ")", ")", ":", "pass", "# already ut1_unix", "elif", "isinstance", "(", "treqlist", "[", "0", "]", ",", "str", ")", ":", "raise", "TypeError", "(", "'parse dates before passing them in here'", ")", "else", ":", "logging", ".", "error", "(", "'I did not understand your time request, falling back to all times'", ")", "reqStart", "=", "0.", "# arbitrary time in the past", "reqStop", "=", "3e9", "# arbitrary time in the future", "except", "AttributeError", ":", "reqStart", "=", "0.", "# arbitrary time in the past", "reqStop", "=", "3e9", "# arbitrary time in the future", "# %% determine mutual start/stop frame", "# FIXME: assumes that all cameras overlap in time at least a little.", "# we will play only over UTC times for which both sites have frames available", "# who started last", "mutualStart", "=", "max", "(", "[", "C", ".", "filestartutc", "for", "C", "in", "cam", "if", "C", ".", "usecam", "]", ")", "mutualStop", "=", "min", "(", "[", "C", ".", "filestoputc", "for", "C", "in", "cam", "if", "C", ".", "usecam", "]", ")", "# who ended first", "# %% make playback time steps", "\"\"\"\n based on the \"simulated\" UTC times that do not necessarily correspond exactly\n with either camera.\n \"\"\"", "tall", "=", "arange", "(", "mutualStart", ",", "mutualStop", ",", "sim", ".", "kineticsec", ")", "logging", ".", "info", "(", "f'{tall.size} mutual frames available '", "f'from {datetime.utcfromtimestamp(mutualStart)}'", "f'to {datetime.utcfromtimestamp(mutualStop)}'", ")", "# %% adjust start/stop to user request", "try", ":", "treq", "=", "treqlist", "except", "NameError", ":", "# keep greater than start time", "treq", "=", "tall", "[", "(", "tall", ">", "reqStart", ")", "&", "(", "tall", "<", "reqStop", ")", "]", "assert", "len", "(", "treq", ")", ">", "0", ",", "'did not find any times within your limits'", "logging", ".", "info", "(", "'Per user specification, analyzing {} frames from {} to {}'", ".", "format", "(", "treq", ".", "size", ",", "treq", "[", "0", "]", ",", "treq", "[", "-", "1", "]", ")", ")", "# %% use *nearest neighbor* interpolation to find mutual frames to display.", "\"\"\" sometimes one camera will have frames repeated, while the other camera\n might skip some frames altogether\n \"\"\"", "for", "C", "in", "cam", ":", "if", "C", ".", "usecam", ":", "ft", "=", "interp1d", "(", "C", ".", "ut1unix", ",", "arange", "(", "C", ".", "ut1unix", ".", "size", ",", "dtype", "=", "int", ")", ",", "kind", "=", "'nearest'", ",", "bounds_error", "=", "False", ")", "ind", "=", "around", "(", "ft", "(", "treq", ")", ")", "ind", "=", "ind", "[", "isfinite", "(", "ind", ")", "]", "# discard requests outside of file bounds", "# these are the indices for each time (the slower camera will use some frames twice in a row)", "C", ".", "pbInd", "=", "ind", ".", "astype", "(", "int", ")", "print", "(", "'using frames {} to {} for camera {}'", ".", "format", "(", "C", ".", "pbInd", "[", "0", "]", ",", "C", ".", "pbInd", "[", "-", "1", "]", ",", "C", ".", "name", ")", ")", "sim", ".", "nTimeSlice", "=", "treq", ".", "size", "return", "cam", ",", "sim" ]

[ "this", "function", "now", "uses", "UT1", "time", "--", "seconds", "since", "1970", "Jan", "1" ]

[ "def", "write_to_fullarr", "(", "data", ",", "sample", ",", "sidx", ")", ":", "## enter ref data?", "#isref = 'reference' in data.paramsdict[\"assembly_method\"]", "LOGGER", ".", "info", "(", "\"writing fullarr %s %s\"", ",", "sample", ".", "name", ",", "sidx", ")", "## save big arrays to disk temporarily", "with", "h5py", ".", "File", "(", "data", ".", "clust_database", ",", "'r+'", ")", "as", "io5", ":", "## open views into the arrays we plan to fill", "chunk", "=", "io5", "[", "\"catgs\"", "]", ".", "attrs", "[", "\"chunksize\"", "]", "[", "0", "]", "catg", "=", "io5", "[", "\"catgs\"", "]", "nall", "=", "io5", "[", "\"nalleles\"", "]", "## adding an axis to newcatg makes it write about 1000X faster.", "smpio", "=", "os", ".", "path", ".", "join", "(", "data", ".", "dirs", ".", "across", ",", "sample", ".", "name", "+", "'.tmp.h5'", ")", "with", "h5py", ".", "File", "(", "smpio", ")", "as", "indat", ":", "## grab all of the data from this sample's arrays", "newcatg", "=", "indat", "[", "\"icatg\"", "]", "#[:]", "onall", "=", "indat", "[", "\"inall\"", "]", "#[:]", "## enter it into the full array one chunk at a time", "for", "cidx", "in", "xrange", "(", "0", ",", "catg", ".", "shape", "[", "0", "]", ",", "chunk", ")", ":", "end", "=", "cidx", "+", "chunk", "catg", "[", "cidx", ":", "end", ",", "sidx", ":", "sidx", "+", "1", ",", ":", "]", "=", "np", ".", "expand_dims", "(", "newcatg", "[", "cidx", ":", "end", ",", ":", "]", ",", "axis", "=", "1", ")", "nall", "[", ":", ",", "sidx", ":", "sidx", "+", "1", "]", "=", "np", ".", "expand_dims", "(", "onall", ",", "axis", "=", "1", ")" ]

[ "writes", "arrays", "to", "h5", "disk" ]

[ "def", "_coords_conv", "(", "self", ",", "pos", ")", ":", "px", "=", "(", "self", ".", "original_size", "[", "0", "]", "/", "2", "+", "pos", "[", "0", "]", ")", "*", "self", ".", "scale_factor", "py", "=", "(", "self", ".", "original_size", "[", "1", "]", "/", "2", "-", "pos", "[", "1", "]", ")", "*", "self", ".", "scale_factor", "return", "round", "(", "px", ",", "2", ")", ",", "round", "(", "py", ",", "2", ")" ]

[ "For", "Svg", "coordinate", "system", "reflect", "over", "X", "axis", "and", "translate", "from", "center", "to", "top", "-", "left" ]

[ "def", "get_vm", "(", "self", ",", "name", ",", "path", "=", "\"\"", ")", ":", "if", "path", ":", "return", "self", ".", "get_obj", "(", "[", "vim", ".", "VirtualMachine", "]", ",", "name", ",", "path", "=", "path", ")", "else", ":", "return", "self", ".", "get_obj", "(", "[", "vim", ".", "VirtualMachine", "]", ",", "name", ")" ]

[ "Get", "a", "VirtualMachine", "object" ]

[ "def", "comment", "(", "self", ",", "body", ")", ":", "self", ".", "github_request", ".", "comment", "(", "issue", "=", "self", ",", "body", "=", "body", ")", "if", "self", ".", "state", "==", "'closed'", ":", "self", ".", "open_issue", "(", ")", "return", "self" ]

[ "Adds", "a", "comment", "to", "the", "issue", "." ]

[ "def", "parse", "(", "cls", ",", "element", ")", ":", "if", "element", ".", "tag", "!=", "cls", ".", "AGENT_TAG", ":", "raise", "exceptions", ".", "ParseError", "(", "u\"Agent got unexpected tag {}; expected {}\"", ".", "format", "(", "element", ".", "tag", ",", "cls", ".", "AGENT_TAG", ")", ")", "role", "=", "element", ".", "get", "(", "u\"ROLE\"", ")", "if", "not", "role", ":", "raise", "exceptions", ".", "ParseError", "(", "u\"Agent must have a ROLE attribute.\"", ")", "if", "role", "==", "u\"OTHER\"", ":", "role", "=", "element", ".", "get", "(", "u\"OTHERROLE\"", ")", "or", "role", "agent_type", "=", "element", ".", "get", "(", "u\"TYPE\"", ")", "if", "agent_type", "==", "u\"OTHER\"", ":", "agent_type", "=", "element", ".", "get", "(", "u\"OTHERTYPE\"", ")", "or", "agent_type", "agent_id", "=", "element", ".", "get", "(", "u\"ID\"", ")", "try", ":", "name", "=", "element", ".", "find", "(", "cls", ".", "NAME_TAG", ")", ".", "text", "except", "AttributeError", ":", "name", "=", "None", "notes", "=", "[", "note", ".", "text", "for", "note", "in", "element", ".", "findall", "(", "cls", ".", "NOTE_TAG", ")", "]", "return", "cls", "(", "role", ",", "id", "=", "agent_id", ",", "type", "=", "agent_type", ",", "name", "=", "name", ",", "notes", "=", "notes", ")" ]

[ "Create", "a", "new", "Agent", "by", "parsing", "root", "." ]

[ "def", "parse_content_disposition", "(", "text", ")", ":", "match", "=", "re", ".", "search", "(", "r'filename\\s*=\\s*(.+)'", ",", "text", ",", "re", ".", "IGNORECASE", ")", "if", "not", "match", ":", "return", "filename", "=", "match", ".", "group", "(", "1", ")", "if", "filename", "[", "0", "]", "in", "'\"\\''", ":", "match", "=", "re", ".", "match", "(", "r'(.)(.+)(?!\\\\)\\1'", ",", "filename", ")", "if", "match", ":", "filename", "=", "match", ".", "group", "(", "2", ")", ".", "replace", "(", "'\\\\\"'", ",", "'\"'", ")", "return", "filename", "else", ":", "filename", "=", "filename", ".", "partition", "(", "';'", ")", "[", "0", "]", ".", "strip", "(", ")", "return", "filename" ]

[ "Parse", "a", "Content", "-", "Disposition", "header", "value", "." ]

[ "def", "peak_interval", "(", "data", ",", "alpha", "=", "_alpha", ",", "npoints", "=", "_npoints", ")", ":", "peak", "=", "kde_peak", "(", "data", ",", "npoints", ")", "x", "=", "np", ".", "sort", "(", "data", ".", "flat", ")", "n", "=", "len", "(", "x", ")", "# The number of entries in the interval", "window", "=", "int", "(", "np", ".", "rint", "(", "(", "1.0", "-", "alpha", ")", "*", "n", ")", ")", "# The start, stop, and width of all possible intervals", "starts", "=", "x", "[", ":", "n", "-", "window", "]", "ends", "=", "x", "[", "window", ":", "]", "widths", "=", "ends", "-", "starts", "# Just the intervals containing the peak", "select", "=", "(", "peak", ">=", "starts", ")", "&", "(", "peak", "<=", "ends", ")", "widths", "=", "widths", "[", "select", "]", "if", "len", "(", "widths", ")", "==", "0", ":", "raise", "ValueError", "(", "'Too few elements for interval calculation'", ")", "min_idx", "=", "np", ".", "argmin", "(", "widths", ")", "lo", "=", "x", "[", "min_idx", "]", "hi", "=", "x", "[", "min_idx", "+", "window", "]", "return", "interval", "(", "peak", ",", "lo", ",", "hi", ")" ]

[ "Identify", "interval", "using", "Gaussian", "kernel", "density", "estimator", "." ]

[ "def", "process_text", "(", "text", ",", "output_fmt", "=", "'json'", ",", "outbuf", "=", "None", ",", "cleanup", "=", "True", ",", "key", "=", "''", ",", "*", "*", "kwargs", ")", ":", "nxml_str", "=", "make_nxml_from_text", "(", "text", ")", "return", "process_nxml_str", "(", "nxml_str", ",", "output_fmt", ",", "outbuf", ",", "cleanup", ",", "key", ",", "*", "*", "kwargs", ")" ]

[ "Return", "processor", "with", "Statements", "extracted", "by", "reading", "text", "with", "Sparser", "." ]

[ "async", "def", "xgroup_del_consumer", "(", "self", ",", "name", ":", "str", ",", "group", ":", "str", ",", "consumer", ":", "str", ")", "->", "int", ":", "return", "await", "self", ".", "execute_command", "(", "'XGROUP DELCONSUMER'", ",", "name", ",", "group", ",", "consumer", ")" ]

[ "[", "NOTICE", "]", "Not", "officially", "released", "yet", "XGROUP", "is", "used", "in", "order", "to", "create", "destroy", "and", "manage", "consumer", "groups", ".", ":", "param", "name", ":", "name", "of", "the", "stream", ":", "param", "group", ":", "name", "of", "the", "consumer", "group", ":", "param", "consumer", ":", "name", "of", "the", "consumer" ]

[ "def", "get_request_handler_chain", "(", "self", ",", "handler_input", ")", ":", "# type: (Input) -> Union[GenericRequestHandlerChain, None]", "for", "chain", "in", "self", ".", "request_handler_chains", ":", "handler", "=", "chain", ".", "request_handler", "# type: AbstractRequestHandler", "if", "handler", ".", "can_handle", "(", "handler_input", "=", "handler_input", ")", ":", "return", "chain", "return", "None" ]

[ "Get", "the", "request", "handler", "chain", "that", "can", "handle", "the", "dispatch", "input", "." ]

[ "def", "httpd_cmd", "(", "broker", ")", ":", "ps", "=", "broker", "[", "DefaultSpecs", ".", "ps_auxww", "]", ".", "content", "ps_httpds", "=", "set", "(", ")", "for", "p", "in", "ps", ":", "p_splits", "=", "p", ".", "split", "(", "None", ",", "10", ")", "if", "len", "(", "p_splits", ")", ">=", "11", ":", "cmd", "=", "p_splits", "[", "10", "]", ".", "split", "(", ")", "[", "0", "]", "# Should compatible with RHEL6", "# e.g. /usr/sbin/httpd, /usr/sbin/httpd.worker and /usr/sbin/httpd.event", "# and SCL's httpd24-httpd", "if", "os", ".", "path", ".", "basename", "(", "cmd", ")", ".", "startswith", "(", "'httpd'", ")", ":", "ps_httpds", ".", "add", "(", "cmd", ")", "# Running multiple httpd instances on RHEL is supported", "# https://access.redhat.com/solutions/21680", "return", "list", "(", "ps_httpds", ")" ]

[ "Command", ":", "httpd_command" ]

[ "def", "safe_put_bulk", "(", "self", ",", "url", ",", "bulk_json", ")", ":", "headers", "=", "{", "\"Content-Type\"", ":", "\"application/x-ndjson\"", "}", "try", ":", "res", "=", "self", ".", "requests", ".", "put", "(", "url", "+", "'?refresh=true'", ",", "data", "=", "bulk_json", ",", "headers", "=", "headers", ")", "res", ".", "raise_for_status", "(", ")", "except", "UnicodeEncodeError", ":", "# Related to body.encode('iso-8859-1'). mbox data", "logger", ".", "error", "(", "\"Encondig error ... converting bulk to iso-8859-1\"", ")", "bulk_json", "=", "bulk_json", ".", "encode", "(", "'iso-8859-1'", ",", "'ignore'", ")", "res", "=", "self", ".", "requests", ".", "put", "(", "url", ",", "data", "=", "bulk_json", ",", "headers", "=", "headers", ")", "res", ".", "raise_for_status", "(", ")", "result", "=", "res", ".", "json", "(", ")", "failed_items", "=", "[", "]", "if", "result", "[", "'errors'", "]", ":", "# Due to multiple errors that may be thrown when inserting bulk data, only the first error is returned", "failed_items", "=", "[", "item", "[", "'index'", "]", "for", "item", "in", "result", "[", "'items'", "]", "if", "'error'", "in", "item", "[", "'index'", "]", "]", "error", "=", "str", "(", "failed_items", "[", "0", "]", "[", "'error'", "]", ")", "logger", ".", "error", "(", "\"Failed to insert data to ES: %s, %s\"", ",", "error", ",", "self", ".", "anonymize_url", "(", "url", ")", ")", "inserted_items", "=", "len", "(", "result", "[", "'items'", "]", ")", "-", "len", "(", "failed_items", ")", "# The exception is currently not thrown to avoid stopping ocean uploading processes", "try", ":", "if", "failed_items", ":", "raise", "ELKError", "(", "cause", "=", "error", ")", "except", "ELKError", ":", "pass", "logger", ".", "debug", "(", "\"%i items uploaded to ES (%s)\"", ",", "inserted_items", ",", "self", ".", "anonymize_url", "(", "url", ")", ")", "return", "inserted_items" ]

[ "Bulk", "PUT", "controlling", "unicode", "issues" ]

[ "def", "distance_to", "(", "self", ",", "point", ")", ":", "angle", "=", "math", ".", "acos", "(", "sin", "(", "self", ".", "lat_radians", ")", "*", "sin", "(", "point", ".", "lat_radians", ")", "+", "cos", "(", "self", ".", "lat_radians", ")", "*", "cos", "(", "point", ".", "lat_radians", ")", "*", "cos", "(", "self", ".", "long_radians", "-", "point", ".", "long_radians", ")", ")", "return", "angle", "*", "EARTH_RADIUS" ]

[ "Return", "the", "distance", "between", "this", "point", "and", "another", "point", "in", "meters", "." ]

[ "def", "ignore_exception", "(", "exception_class", ")", ":", "def", "_decorator", "(", "func", ")", ":", "def", "newfunc", "(", "*", "args", ",", "*", "*", "kwds", ")", ":", "try", ":", "return", "func", "(", "*", "args", ",", "*", "*", "kwds", ")", "except", "exception_class", ":", "pass", "return", "newfunc", "return", "_decorator" ]

[ "A", "decorator", "that", "ignores", "exception_class", "exceptions" ]

[ "def", "delete", "(", "self", ")", ":", "SQL", "=", "'DELETE FROM %s'", "%", "self", ".", "_table", "if", "self", ".", "_selectors", ":", "SQL", "=", "' '", ".", "join", "(", "[", "SQL", ",", "'WHERE'", ",", "self", ".", "_selectors", "]", ")", ".", "strip", "(", ")", "return", "SQL" ]

[ "return", "DELETE", "SQL" ]

[ "async", "def", "create", "(", "source_id", ":", "str", ",", "proof_request", ":", "str", ")", ":", "constructor_params", "=", "(", "source_id", ",", ")", "c_source_id", "=", "c_char_p", "(", "source_id", ".", "encode", "(", "'utf-8'", ")", ")", "c_proof_request", "=", "c_char_p", "(", "json", ".", "dumps", "(", "proof_request", ")", ".", "encode", "(", "'utf-8'", ")", ")", "c_params", "=", "(", "c_source_id", ",", "c_proof_request", ",", ")", "return", "await", "DisclosedProof", ".", "_create", "(", "\"vcx_disclosed_proof_create_with_request\"", ",", "constructor_params", ",", "c_params", ")" ]

[ "Create", "a", "proof", "for", "fulfilling", "a", "corresponding", "proof", "request", ":", "param", "source_id", ":", "Tag", "associated", "by", "user", "of", "sdk", ":", "param", "proof_request", ":", "Proof", "Request", "data", "sent", "by", "requestor", ".", "Example", ":", "source_id", "=", "sourceId", "request", "=", "{" ]

[ "def", "get_file_status", "(", "self", ",", "path", ",", "*", "*", "kwargs", ")", ":", "return", "FileStatus", "(", "*", "*", "_json", "(", "self", ".", "_get", "(", "path", ",", "'GETFILESTATUS'", ",", "*", "*", "kwargs", ")", ")", "[", "'FileStatus'", "]", ")" ]

[ "Return", "a", ":", "py", ":", "class", ":", "FileStatus", "object", "that", "represents", "the", "path", "." ]

[ "def", "_png", "(", "code", ",", "version", ",", "file", ",", "scale", "=", "1", ",", "module_color", "=", "(", "0", ",", "0", ",", "0", ",", "255", ")", ",", "background", "=", "(", "255", ",", "255", ",", "255", ",", "255", ")", ",", "quiet_zone", "=", "4", ",", "debug", "=", "False", ")", ":", "import", "png", "# Coerce scale parameter into an integer", "try", ":", "scale", "=", "int", "(", "scale", ")", "except", "ValueError", ":", "raise", "ValueError", "(", "'The scale parameter must be an integer'", ")", "def", "scale_code", "(", "size", ")", ":", "\"\"\"To perform the scaling we need to inflate the number of bits.\n The PNG library expects all of the bits when it draws the PNG.\n Effectively, we double, tripple, etc. the number of columns and\n the number of rows.\n \"\"\"", "# This is one row's worth of each possible module", "# PNG's use 0 for black and 1 for white, this is the", "# reverse of the QR standard", "black", "=", "[", "0", "]", "*", "scale", "white", "=", "[", "1", "]", "*", "scale", "# Tuple to lookup colors", "# The 3rd color is the module_color unless \"debug\" is enabled", "colors", "=", "(", "white", ",", "black", ",", "(", "(", "[", "2", "]", "*", "scale", ")", "if", "debug", "else", "black", ")", ")", "# Whitespace added on the left and right side", "border_module", "=", "white", "*", "quiet_zone", "# This is the row to show up at the top and bottom border", "border_row", "=", "[", "[", "1", "]", "*", "size", "]", "*", "scale", "*", "quiet_zone", "# This will hold the final PNG's bits", "bits", "=", "[", "]", "# Add scale rows before the code as a border,", "# as per the standard", "bits", ".", "extend", "(", "border_row", ")", "# Add each row of the to the final PNG bits", "for", "row", "in", "code", ":", "tmp_row", "=", "[", "]", "# Add one all white module to the beginning", "# to create the vertical border", "tmp_row", ".", "extend", "(", "border_module", ")", "# Go through each bit in the code", "for", "bit", "in", "row", ":", "# Use the standard color or the \"debug\" color", "tmp_row", ".", "extend", "(", "colors", "[", "(", "bit", "if", "bit", "in", "(", "0", ",", "1", ")", "else", "2", ")", "]", ")", "# Add one all white module to the end", "# to create the vertical border", "tmp_row", ".", "extend", "(", "border_module", ")", "# Copy each row scale times", "for", "n", "in", "range", "(", "scale", ")", ":", "bits", ".", "append", "(", "tmp_row", ")", "# Add the bottom border", "bits", ".", "extend", "(", "border_row", ")", "return", "bits", "def", "png_pallete_color", "(", "color", ")", ":", "\"\"\"This creates a palette color from a list or tuple. The list or\n tuple must be of length 3 (for rgb) or 4 (for rgba). The values\n must be between 0 and 255. Note rgb colors will be given an added\n alpha component set to 255.\n\n The pallete color is represented as a list, this is what is returned.\n \"\"\"", "if", "color", "is", "None", ":", "return", "(", ")", "if", "not", "isinstance", "(", "color", ",", "(", "tuple", ",", "list", ")", ")", ":", "r", ",", "g", ",", "b", "=", "_hex_to_rgb", "(", "color", ")", "return", "r", ",", "g", ",", "b", ",", "255", "rgba", "=", "[", "]", "if", "not", "(", "3", "<=", "len", "(", "color", ")", "<=", "4", ")", ":", "raise", "ValueError", "(", "'Colors must be a list or tuple of length '", "' 3 or 4. You passed in \"{0}\".'", ".", "format", "(", "color", ")", ")", "for", "c", "in", "color", ":", "c", "=", "int", "(", "c", ")", "if", "0", "<=", "c", "<=", "255", ":", "rgba", ".", "append", "(", "int", "(", "c", ")", ")", "else", ":", "raise", "ValueError", "(", "'Color components must be between 0 and 255'", ")", "# Make all colors have an alpha channel", "if", "len", "(", "rgba", ")", "==", "3", ":", "rgba", ".", "append", "(", "255", ")", "return", "tuple", "(", "rgba", ")", "if", "module_color", "is", "None", ":", "raise", "ValueError", "(", "'The module_color must not be None'", ")", "bitdepth", "=", "1", "# foreground aka module color", "fg_col", "=", "png_pallete_color", "(", "module_color", ")", "transparent", "=", "background", "is", "None", "# If background color is set to None, the inverse color of the", "# foreground color is calculated", "bg_col", "=", "png_pallete_color", "(", "background", ")", "if", "background", "is", "not", "None", "else", "tuple", "(", "[", "255", "-", "c", "for", "c", "in", "fg_col", "]", ")", "# Assume greyscale if module color is black and background color is white", "greyscale", "=", "fg_col", "[", ":", "3", "]", "==", "(", "0", ",", "0", ",", "0", ")", "and", "(", "not", "debug", "and", "transparent", "or", "bg_col", "==", "(", "255", ",", "255", ",", "255", ",", "255", ")", ")", "transparent_color", "=", "1", "if", "transparent", "and", "greyscale", "else", "None", "palette", "=", "[", "fg_col", ",", "bg_col", "]", "if", "not", "greyscale", "else", "None", "if", "debug", ":", "# Add \"red\" as color for error modules", "palette", ".", "append", "(", "(", "255", ",", "0", ",", "0", ",", "255", ")", ")", "bitdepth", "=", "2", "# The size of the PNG", "size", "=", "_get_png_size", "(", "version", ",", "scale", ",", "quiet_zone", ")", "# We need to increase the size of the code to match up to the", "# scale parameter.", "code_rows", "=", "scale_code", "(", "size", ")", "# Write out the PNG", "f", ",", "autoclose", "=", "_get_writable", "(", "file", ",", "'wb'", ")", "w", "=", "png", ".", "Writer", "(", "width", "=", "size", ",", "height", "=", "size", ",", "greyscale", "=", "greyscale", ",", "transparent", "=", "transparent_color", ",", "palette", "=", "palette", ",", "bitdepth", "=", "bitdepth", ")", "try", ":", "w", ".", "write", "(", "f", ",", "code_rows", ")", "finally", ":", "if", "autoclose", ":", "f", ".", "close", "(", ")" ]

[ "See", ":", "pyqrcode", ".", "QRCode", ".", "png", "()" ]

[ "def", "make_fileitem_peinfo_petimestamp", "(", "compile_time", ",", "condition", "=", "'is'", ",", "negate", "=", "False", ")", ":", "document", "=", "'FileItem'", "search", "=", "'FileItem/PEInfo/PETimeStamp'", "content_type", "=", "'date'", "content", "=", "compile_time", "ii_node", "=", "ioc_api", ".", "make_indicatoritem_node", "(", "condition", ",", "document", ",", "search", ",", "content_type", ",", "content", ",", "negate", "=", "negate", ")", "return", "ii_node" ]

[ "Create", "a", "node", "for", "FileItem", "/", "PEInfo", "/", "PETimeStamp", ":", "return", ":", "A", "IndicatorItem", "represented", "as", "an", "Element", "node" ]

[ "def", "create_shortcuts", "(", "self", ")", ":", "inspect", "=", "config_shortcut", "(", "self", ".", "_control", ".", "inspect_current_object", ",", "context", "=", "'Console'", ",", "name", "=", "'Inspect current object'", ",", "parent", "=", "self", ")", "clear_console", "=", "config_shortcut", "(", "self", ".", "clear_console", ",", "context", "=", "'Console'", ",", "name", "=", "'Clear shell'", ",", "parent", "=", "self", ")", "restart_kernel", "=", "config_shortcut", "(", "self", ".", "ipyclient", ".", "restart_kernel", ",", "context", "=", "'ipython_console'", ",", "name", "=", "'Restart kernel'", ",", "parent", "=", "self", ")", "new_tab", "=", "config_shortcut", "(", "lambda", ":", "self", ".", "new_client", ".", "emit", "(", ")", ",", "context", "=", "'ipython_console'", ",", "name", "=", "'new tab'", ",", "parent", "=", "self", ")", "reset_namespace", "=", "config_shortcut", "(", "lambda", ":", "self", ".", "_reset_namespace", "(", ")", ",", "context", "=", "'ipython_console'", ",", "name", "=", "'reset namespace'", ",", "parent", "=", "self", ")", "array_inline", "=", "config_shortcut", "(", "self", ".", "_control", ".", "enter_array_inline", ",", "context", "=", "'array_builder'", ",", "name", "=", "'enter array inline'", ",", "parent", "=", "self", ")", "array_table", "=", "config_shortcut", "(", "self", ".", "_control", ".", "enter_array_table", ",", "context", "=", "'array_builder'", ",", "name", "=", "'enter array table'", ",", "parent", "=", "self", ")", "clear_line", "=", "config_shortcut", "(", "self", ".", "ipyclient", ".", "clear_line", ",", "context", "=", "'console'", ",", "name", "=", "'clear line'", ",", "parent", "=", "self", ")", "return", "[", "inspect", ",", "clear_console", ",", "restart_kernel", ",", "new_tab", ",", "reset_namespace", ",", "array_inline", ",", "array_table", ",", "clear_line", "]" ]

[ "Create", "shortcuts", "for", "ipyconsole", "." ]

[ "def", "ddl_target_table", "(", "self", ")", ":", "prop", "=", "self", ".", "_job_statistics", "(", ")", ".", "get", "(", "\"ddlTargetTable\"", ")", "if", "prop", "is", "not", "None", ":", "prop", "=", "TableReference", ".", "from_api_repr", "(", "prop", ")", "return", "prop" ]

[ "Optional", "[", "TableReference", "]", ":", "Return", "the", "DDL", "target", "table", "present", "for", "CREATE", "/", "DROP", "TABLE", "/", "VIEW", "queries", "." ]

[ "def", "list", "(", "self", ",", "limit", "=", "None", ",", "marker", "=", "None", ",", "return_next", "=", "False", ")", ":", "kwargs", "=", "{", "}", "if", "return_next", ":", "kwargs", "[", "\"other_keys\"", "]", "=", "\"metadata\"", "ret", "=", "super", "(", "_PaginationManager", ",", "self", ")", ".", "list", "(", "limit", "=", "limit", ",", "marker", "=", "marker", ",", "*", "*", "kwargs", ")", "if", "return_next", ":", "ents", ",", "meta", "=", "ret", "return", "(", "ents", ",", "meta", "[", "0", "]", ".", "get", "(", "\"next_marker\"", ")", ")", "else", ":", "return", "ret" ]

[ "This", "is", "necessary", "to", "handle", "pagination", "correctly", "as", "the", "Monitoring", "service", "defines", "marker", "differently", "than", "most", "other", "services", ".", "For", "monitoring", "marker", "represents", "the", "first", "item", "in", "the", "next", "page", "whereas", "other", "services", "define", "it", "as", "the", "ID", "of", "the", "last", "item", "in", "the", "current", "page", "." ]

[ "def", "RootGroup", "(", "self", ")", ":", "return", "(", "clc", ".", "v2", ".", "Group", "(", "id", "=", "self", ".", "root_group_id", ",", "alias", "=", "self", ".", "alias", ",", "session", "=", "self", ".", "session", ")", ")" ]

[ "Returns", "group", "object", "for", "datacenter", "root", "group", "." ]

[ "def", "_build_authorization_request_url", "(", "self", ",", "response_type", ",", "state", "=", "None", ")", ":", "if", "response_type", "not", "in", "auth", ".", "VALID_RESPONSE_TYPES", ":", "message", "=", "'{} is not a valid response type.'", "raise", "LyftIllegalState", "(", "message", ".", "format", "(", "response_type", ")", ")", "args", "=", "OrderedDict", "(", "[", "(", "'scope'", ",", "' '", ".", "join", "(", "self", ".", "scopes", ")", ")", ",", "(", "'state'", ",", "state", ")", ",", "(", "'response_type'", ",", "response_type", ")", ",", "(", "'client_id'", ",", "self", ".", "client_id", ")", ",", "]", ")", "return", "build_url", "(", "auth", ".", "SERVER_HOST", ",", "auth", ".", "AUTHORIZE_PATH", ",", "args", ")" ]

[ "Form", "URL", "to", "request", "an", "auth", "code", "or", "access", "token", ".", "Parameters", "response_type", "(", "str", ")", "Only", "code", "(", "Authorization", "Code", "Grant", ")", "supported", "at", "this", "time", "state", "(", "str", ")", "Optional", "CSRF", "State", "token", "to", "send", "to", "server", ".", "Returns", "(", "str", ")", "The", "fully", "constructed", "authorization", "request", "URL", ".", "Raises", "LyftIllegalState", "(", "ApiError", ")", "Raised", "if", "response_type", "parameter", "is", "invalid", "." ]

[ "def", "ensure_timezone", "(", "dt", ",", "tz", "=", "None", ")", ":", "if", "dt", ".", "tzinfo", "is", "None", ":", "return", "dt", ".", "replace", "(", "tzinfo", "=", "tz", "or", "tzlocal", "(", ")", ")", "else", ":", "return", "dt" ]

[ "Make", "sure", "the", "datetime", "<dt", ">", "has", "a", "timezone", "set", "using", "timezone", "<tz", ">", "if", "it", "doesn", "t", ".", "<tz", ">", "defaults", "to", "the", "local", "timezone", "." ]

[ "def", "acquire", "(", "self", ",", "timeout", "=", "None", ")", ":", "if", "self", ".", "held", "is", "True", ":", "# NOTE: Without some type of in-directory marker (like a uuid) we cannot", "# refresh an expired lock accurately", "if", "os", ".", "path", ".", "exists", "(", "self", ".", "lockPath", ")", ":", "return", "True", "# Someone removed our lock", "self", ".", "held", "=", "False", "# If we aren't going to poll at least 5 times, give us a smaller interval", "if", "timeout", ":", "if", "timeout", "/", "5.0", "<", "DEFAULT_POLL_TIME", ":", "pollTime", "=", "timeout", "/", "10.0", "else", ":", "pollTime", "=", "DEFAULT_POLL_TIME", "endTime", "=", "time", ".", "time", "(", ")", "+", "timeout", "keepGoing", "=", "lambda", ":", "bool", "(", "time", ".", "time", "(", ")", "<", "endTime", ")", "else", ":", "pollTime", "=", "DEFAULT_POLL_TIME", "keepGoing", "=", "lambda", ":", "True", "success", "=", "False", "while", "keepGoing", "(", ")", ":", "try", ":", "os", ".", "mkdir", "(", "self", ".", "lockPath", ")", "success", "=", "True", "break", "except", ":", "time", ".", "sleep", "(", "pollTime", ")", "if", "self", ".", "maxLockAge", ":", "if", "os", ".", "path", ".", "exists", "(", "self", ".", "lockPath", ")", "and", "os", ".", "stat", "(", "self", ".", "lockPath", ")", ".", "st_mtime", "<", "time", ".", "time", "(", ")", "-", "self", ".", "maxLockAge", ":", "try", ":", "os", ".", "rmdir", "(", "self", ".", "lockPath", ")", "except", ":", "# If we did not remove the lock, someone else is at the same point and contending. Let them win.", "time", ".", "sleep", "(", "pollTime", ")", "if", "success", "is", "True", ":", "self", ".", "acquiredAt", "=", "time", ".", "time", "(", ")", "self", ".", "held", "=", "success", "return", "success" ]

[ "acquire", "-", "Acquire", "given", "lock", ".", "Can", "be", "blocking", "or", "nonblocking", "by", "providing", "a", "timeout", ".", "Returns", "True", "if", "you", "got", "the", "lock", "otherwise", "False" ]

[ "def", "near_to_position", "(", "self", ",", "position", ",", "max_distance", ")", ":", "end", "=", "self", ".", "ref_end_pos", "(", ")", "return", "self", ".", "POS", "<=", "position", "<=", "end", "or", "abs", "(", "position", "-", "self", ".", "POS", ")", "<=", "max_distance", "or", "abs", "(", "position", "-", "end", ")", "<=", "max_distance" ]

[ "Returns", "true", "iff", "the", "record", "is", "within", "max_distance", "of", "the", "given", "position", ".", "Note", ":", "chromosome", "name", "not", "checked", "so", "that", "s", "up", "to", "you", "to", "do", "first", "." ]

[ "def", "checkout_branch", "(", "self", ",", "branch_name", ")", ":", "cmd", "=", "[", "\"git\"", ",", "\"checkout\"", ",", "\"-b\"", ",", "self", ".", "get_cherry_pick_branch", "(", "branch_name", ")", ",", "f\"{self.upstream}/{branch_name}\"", ",", "]", "try", ":", "self", ".", "run_cmd", "(", "cmd", ")", "except", "subprocess", ".", "CalledProcessError", "as", "err", ":", "click", ".", "echo", "(", "f\"Error checking out the branch {self.get_cherry_pick_branch(branch_name)}.\"", ")", "click", ".", "echo", "(", "err", ".", "output", ")", "raise", "BranchCheckoutException", "(", "f\"Error checking out the branch {self.get_cherry_pick_branch(branch_name)}.\"", ")" ]

[ "git", "checkout", "-", "b", "<branch_name", ">" ]

[ "def", "affine_mat", "(", "self", ")", "->", "AffineMatrix", ":", "if", "self", ".", "_affine_mat", "is", "None", ":", "self", ".", "_affine_mat", "=", "torch", ".", "eye", "(", "3", ")", ".", "to", "(", "self", ".", "device", ")", "return", "self", ".", "_affine_mat" ]

[ "Get", "the", "affine", "matrix", "that", "will", "be", "applied", "by", "refresh", "." ]

[ "def", "get_R_mod", "(", "options", ",", "rho0", ")", ":", "tomodir", "=", "tdManager", ".", "tdMan", "(", "elem_file", "=", "options", ".", "elem_file", ",", "elec_file", "=", "options", ".", "elec_file", ",", "config_file", "=", "options", ".", "config_file", ",", ")", "# set model", "tomodir", ".", "add_homogeneous_model", "(", "magnitude", "=", "rho0", ")", "# only interested in magnitudes", "Z", "=", "tomodir", ".", "measurements", "(", ")", "[", ":", ",", "0", "]", "return", "Z" ]

[ "Compute", "synthetic", "measurements", "over", "a", "homogeneous", "half", "-", "space" ]

[ "def", "status", "(", "self", ")", ":", "status_list", "=", "[", "]", "for", "platform", "in", "self", ".", "_config", ".", "platforms", ".", "instances", ":", "instance_name", "=", "platform", "[", "'name'", "]", "driver_name", "=", "self", ".", "name", "provisioner_name", "=", "self", ".", "_config", ".", "provisioner", ".", "name", "scenario_name", "=", "self", ".", "_config", ".", "scenario", ".", "name", "status_list", ".", "append", "(", "Status", "(", "instance_name", "=", "instance_name", ",", "driver_name", "=", "driver_name", ",", "provisioner_name", "=", "provisioner_name", ",", "scenario_name", "=", "scenario_name", ",", "created", "=", "self", ".", "_created", "(", ")", ",", "converged", "=", "self", ".", "_converged", "(", ")", ",", ")", ")", "return", "status_list" ]

[ "Collects", "the", "instances", "state", "and", "returns", "a", "list", "." ]

[ "def", "samples_by_indices", "(", "self", ",", "indices", ")", ":", "if", "not", "self", ".", "_random_access", ":", "raise", "TypeError", "(", "'samples_by_indices method not supported as one '", "'or more of the underlying data sources does '", "'not support random access'", ")", "batch", "=", "self", ".", "source", ".", "samples_by_indices", "(", "indices", ")", "return", "self", ".", "fn", "(", "*", "batch", ")" ]

[ "Gather", "a", "batch", "of", "samples", "by", "indices", "applying", "any", "index", "mapping", "defined", "by", "the", "underlying", "data", "sources", "." ]

[ "def", "getFileHandle", "(", "self", ",", "dataFile", ",", "openMethod", ")", ":", "if", "dataFile", "in", "self", ".", "_memoTable", ":", "handle", "=", "self", ".", "_memoTable", "[", "dataFile", "]", "self", ".", "_update", "(", "dataFile", ",", "handle", ")", "return", "handle", "else", ":", "try", ":", "handle", "=", "openMethod", "(", "dataFile", ")", "except", "ValueError", ":", "raise", "exceptions", ".", "FileOpenFailedException", "(", "dataFile", ")", "self", ".", "_memoTable", "[", "dataFile", "]", "=", "handle", "self", ".", "_add", "(", "dataFile", ",", "handle", ")", "if", "len", "(", "self", ".", "_memoTable", ")", ">", "self", ".", "_maxCacheSize", ":", "dataFile", "=", "self", ".", "_removeLru", "(", ")", "del", "self", ".", "_memoTable", "[", "dataFile", "]", "return", "handle" ]

[ "Returns", "handle", "associated", "to", "the", "filename", ".", "If", "the", "file", "is", "already", "opened", "update", "its", "priority", "in", "the", "cache", "and", "return", "its", "handle", ".", "Otherwise", "open", "the", "file", "using", "openMethod", "store", "it", "in", "the", "cache", "and", "return", "the", "corresponding", "handle", "." ]

[ "def", "dictify", "(", "r", ",", "root", "=", "True", ")", ":", "if", "root", ":", "return", "{", "r", ".", "tag", ":", "dictify", "(", "r", ",", "False", ")", "}", "d", "=", "{", "}", "if", "r", ".", "text", "and", "r", ".", "text", ".", "strip", "(", ")", ":", "try", ":", "return", "int", "(", "r", ".", "text", ")", "except", "ValueError", ":", "try", ":", "return", "float", "(", "r", ".", "text", ")", "except", "ValueError", ":", "return", "r", ".", "text", "for", "x", "in", "r", ".", "findall", "(", "\"./*\"", ")", ":", "if", "x", ".", "tag", "in", "d", "and", "not", "isinstance", "(", "d", "[", "x", ".", "tag", "]", ",", "list", ")", ":", "d", "[", "x", ".", "tag", "]", "=", "[", "d", "[", "x", ".", "tag", "]", "]", "d", "[", "x", ".", "tag", "]", ".", "append", "(", "dictify", "(", "x", ",", "False", ")", ")", "else", ":", "d", "[", "x", ".", "tag", "]", "=", "dictify", "(", "x", ",", "False", ")", "return", "d" ]

[ "Convert", "an", "ElementTree", "into", "a", "dict", "." ]

[ "def", "XCHG", "(", "cpu", ",", "dest", ",", "src", ")", ":", "temp", "=", "dest", ".", "read", "(", ")", "dest", ".", "write", "(", "src", ".", "read", "(", ")", ")", "src", ".", "write", "(", "temp", ")" ]

[ "Exchanges", "register", "/", "memory", "with", "register", "." ]

[ "def", "running", "(", "name", ",", "enable", "=", "None", ",", "sig", "=", "None", ",", "init_delay", "=", "None", ",", "no_block", "=", "False", ",", "unmask", "=", "False", ",", "unmask_runtime", "=", "False", ",", "*", "*", "kwargs", ")", ":", "ret", "=", "{", "'name'", ":", "name", ",", "'changes'", ":", "{", "}", ",", "'result'", ":", "True", ",", "'comment'", ":", "''", "}", "# Check for common error: using enabled option instead of enable", "if", "'enabled'", "in", "kwargs", ":", "return", "_enabled_used_error", "(", "ret", ")", "# Convert enable to boolean in case user passed a string value", "if", "isinstance", "(", "enable", ",", "six", ".", "string_types", ")", ":", "enable", "=", "salt", ".", "utils", ".", "data", ".", "is_true", "(", "enable", ")", "# Check if the service is available", "try", ":", "if", "not", "_available", "(", "name", ",", "ret", ")", ":", "if", "__opts__", ".", "get", "(", "'test'", ")", ":", "ret", "[", "'result'", "]", "=", "None", "ret", "[", "'comment'", "]", "=", "'Service {0} not present; if created in this state run, it would have been started'", ".", "format", "(", "name", ")", "return", "ret", "except", "CommandExecutionError", "as", "exc", ":", "ret", "[", "'result'", "]", "=", "False", "ret", "[", "'comment'", "]", "=", "exc", ".", "strerror", "return", "ret", "# lot of custom init script won't or mis implement the status", "# command, so it is just an indicator but can not be fully trusted", "before_toggle_status", "=", "__salt__", "[", "'service.status'", "]", "(", "name", ",", "sig", ")", "if", "'service.enabled'", "in", "__salt__", ":", "before_toggle_enable_status", "=", "__salt__", "[", "'service.enabled'", "]", "(", "name", ")", "else", ":", "before_toggle_enable_status", "=", "True", "unmask_ret", "=", "{", "'comment'", ":", "''", "}", "if", "unmask", ":", "unmask_ret", "=", "unmasked", "(", "name", ",", "unmask_runtime", ")", "# See if the service is already running", "if", "before_toggle_status", ":", "ret", "[", "'comment'", "]", "=", "'\\n'", ".", "join", "(", "[", "_f", "for", "_f", "in", "[", "'The service {0} is already running'", ".", "format", "(", "name", ")", ",", "unmask_ret", "[", "'comment'", "]", "]", "if", "_f", "]", ")", "if", "enable", "is", "True", "and", "not", "before_toggle_enable_status", ":", "ret", ".", "update", "(", "_enable", "(", "name", ",", "None", ",", "skip_verify", "=", "False", ",", "*", "*", "kwargs", ")", ")", "elif", "enable", "is", "False", "and", "before_toggle_enable_status", ":", "ret", ".", "update", "(", "_disable", "(", "name", ",", "None", ",", "skip_verify", "=", "False", ",", "*", "*", "kwargs", ")", ")", "return", "ret", "# Run the tests", "if", "__opts__", "[", "'test'", "]", ":", "ret", "[", "'result'", "]", "=", "None", "ret", "[", "'comment'", "]", "=", "'\\n'", ".", "join", "(", "[", "_f", "for", "_f", "in", "[", "'Service {0} is set to start'", ".", "format", "(", "name", ")", ",", "unmask_ret", "[", "'comment'", "]", "]", "if", "_f", "]", ")", "return", "ret", "# Conditionally add systemd-specific args to call to service.start", "start_kwargs", ",", "warnings", "=", "_get_systemd_only", "(", "__salt__", "[", "'service.start'", "]", ",", "locals", "(", ")", ")", "if", "warnings", ":", "ret", ".", "setdefault", "(", "'warnings'", ",", "[", "]", ")", ".", "extend", "(", "warnings", ")", "if", "salt", ".", "utils", ".", "platform", ".", "is_windows", "(", ")", ":", "for", "arg", "in", "[", "'timeout'", ",", "'with_deps'", ",", "'with_parents'", "]", ":", "if", "kwargs", ".", "get", "(", "arg", ",", "False", ")", ":", "start_kwargs", ".", "update", "(", "{", "arg", ":", "kwargs", ".", "get", "(", "arg", ")", "}", ")", "try", ":", "func_ret", "=", "__salt__", "[", "'service.start'", "]", "(", "name", ",", "*", "*", "start_kwargs", ")", "except", "CommandExecutionError", "as", "exc", ":", "ret", "[", "'result'", "]", "=", "False", "ret", "[", "'comment'", "]", "=", "exc", ".", "strerror", "return", "ret", "if", "not", "func_ret", ":", "ret", "[", "'result'", "]", "=", "False", "ret", "[", "'comment'", "]", "=", "'Service {0} failed to start'", ".", "format", "(", "name", ")", "if", "enable", "is", "True", ":", "ret", ".", "update", "(", "_enable", "(", "name", ",", "False", ",", "result", "=", "False", ",", "skip_verify", "=", "False", ",", "*", "*", "kwargs", ")", ")", "elif", "enable", "is", "False", ":", "ret", ".", "update", "(", "_disable", "(", "name", ",", "False", ",", "result", "=", "False", ",", "skip_verify", "=", "False", ",", "*", "*", "kwargs", ")", ")", "return", "ret", "if", "init_delay", ":", "time", ".", "sleep", "(", "init_delay", ")", "# only force a change state if we have explicitly detected them", "after_toggle_status", "=", "__salt__", "[", "'service.status'", "]", "(", "name", ",", "sig", ")", "if", "'service.enabled'", "in", "__salt__", ":", "after_toggle_enable_status", "=", "__salt__", "[", "'service.enabled'", "]", "(", "name", ")", "else", ":", "after_toggle_enable_status", "=", "True", "if", "(", "(", "before_toggle_enable_status", "!=", "after_toggle_enable_status", ")", "or", "(", "before_toggle_status", "!=", "after_toggle_status", ")", ")", "and", "not", "ret", ".", "get", "(", "'changes'", ",", "{", "}", ")", ":", "ret", "[", "'changes'", "]", "[", "name", "]", "=", "after_toggle_status", "if", "after_toggle_status", ":", "ret", "[", "'comment'", "]", "=", "'Started Service {0}'", ".", "format", "(", "name", ")", "else", ":", "ret", "[", "'comment'", "]", "=", "'Service {0} failed to start'", ".", "format", "(", "name", ")", "ret", "[", "'result'", "]", "=", "False", "if", "enable", "is", "True", ":", "ret", ".", "update", "(", "_enable", "(", "name", ",", "after_toggle_status", ",", "result", "=", "after_toggle_status", ",", "skip_verify", "=", "False", ",", "*", "*", "kwargs", ")", ")", "elif", "enable", "is", "False", ":", "ret", ".", "update", "(", "_disable", "(", "name", ",", "after_toggle_status", ",", "result", "=", "after_toggle_status", ",", "skip_verify", "=", "False", ",", "*", "*", "kwargs", ")", ")", "if", "init_delay", ":", "ret", "[", "'comment'", "]", "=", "(", "'{0}\\nDelayed return for {1} seconds'", ".", "format", "(", "ret", "[", "'comment'", "]", ",", "init_delay", ")", ")", "if", "unmask", ":", "ret", "[", "'comment'", "]", "=", "'\\n'", ".", "join", "(", "[", "ret", "[", "'comment'", "]", ",", "unmask_ret", "[", "'comment'", "]", "]", ")", "return", "ret" ]

[ "Ensure", "that", "the", "service", "is", "running" ]

[ "def", "get_mesh_name_from_web", "(", "mesh_id", ")", ":", "url", "=", "MESH_URL", "+", "mesh_id", "+", "'.json'", "resp", "=", "requests", ".", "get", "(", "url", ")", "if", "resp", ".", "status_code", "!=", "200", ":", "return", "None", "mesh_json", "=", "resp", ".", "json", "(", ")", "try", ":", "label", "=", "mesh_json", "[", "'@graph'", "]", "[", "0", "]", "[", "'label'", "]", "[", "'@value'", "]", "except", "(", "KeyError", ",", "IndexError", ")", "as", "e", ":", "return", "None", "return", "label" ]

[ "Get", "the", "MESH", "label", "for", "the", "given", "MESH", "ID", "using", "the", "NLM", "REST", "API", "." ]

[ "def", "timeout_queue_add", "(", "self", ",", "item", ",", "cache_time", "=", "0", ")", ":", "# add the info to the add queue. We do this so that actually adding", "# the module is done in the core thread.", "self", ".", "timeout_add_queue", ".", "append", "(", "(", "item", ",", "cache_time", ")", ")", "# if the timeout_add_queue is not due to be processed until after this", "# update request is due then trigger an update now.", "if", "self", ".", "timeout_due", "is", "None", "or", "cache_time", "<", "self", ".", "timeout_due", ":", "self", ".", "update_request", ".", "set", "(", ")" ]

[ "Add", "a", "item", "to", "be", "run", "at", "a", "future", "time", ".", "This", "must", "be", "a", "Module", "I3statusModule", "or", "a", "Task" ]

[ "def", "trj_fitandcenter", "(", "xy", "=", "False", ",", "*", "*", "kwargs", ")", ":", "if", "xy", ":", "fitmode", "=", "'rotxy+transxy'", "kwargs", ".", "pop", "(", "'fit'", ",", "None", ")", "else", ":", "fitmode", "=", "kwargs", ".", "pop", "(", "'fit'", ",", "'rot+trans'", ")", "# user can use progressive, too", "intrj", "=", "kwargs", ".", "pop", "(", "'f'", ",", "None", ")", "# get the correct suffix for the intermediate step: only trr will", "# keep velocities/forces!", "suffix", "=", "os", ".", "path", ".", "splitext", "(", "intrj", ")", "[", "1", "]", "if", "not", "suffix", "in", "(", "'xtc'", ",", "'trr'", ")", ":", "suffix", "=", "'.xtc'", "outtrj", "=", "kwargs", ".", "pop", "(", "'o'", ",", "None", ")", "ndx", "=", "kwargs", ".", "pop", "(", "'n'", ",", "None", ")", "ndxcompact", "=", "kwargs", ".", "pop", "(", "'n1'", ",", "ndx", ")", "structures", "=", "kwargs", ".", "pop", "(", "'s'", ",", "None", ")", "if", "type", "(", "structures", ")", "in", "(", "tuple", ",", "list", ")", ":", "try", ":", "compact_structure", ",", "fit_structure", "=", "structures", "except", ":", "raise", "ValueError", "(", "\"argument s must be a pair of tpr/pdb files or a single structure file\"", ")", "else", ":", "compact_structure", "=", "fit_structure", "=", "structures", "inpfit", "=", "kwargs", ".", "pop", "(", "'input'", ",", "(", "'backbone'", ",", "'protein'", ",", "'system'", ")", ")", "try", ":", "_inpcompact", "=", "inpfit", "[", "1", ":", "]", "# use 2nd and 3rd group for compact", "except", "TypeError", ":", "_inpcompact", "=", "None", "inpcompact", "=", "kwargs", ".", "pop", "(", "'input1'", ",", "_inpcompact", ")", "# ... or the user supplied ones", "fd", ",", "tmptrj", "=", "tempfile", ".", "mkstemp", "(", "suffix", "=", "suffix", ",", "prefix", "=", "'pbc_compact_'", ")", "logger", ".", "info", "(", "\"Input structure for PBC: {compact_structure!r}\"", ".", "format", "(", "*", "*", "vars", "(", ")", ")", ")", "logger", ".", "info", "(", "\"Input structure for fit: {fit_structure!r}\"", ".", "format", "(", "*", "*", "vars", "(", ")", ")", ")", "logger", ".", "info", "(", "\"Input trajectory: {intrj!r}\"", ".", "format", "(", "*", "*", "vars", "(", ")", ")", ")", "logger", ".", "info", "(", "\"Output trajectory: {outtrj!r}\"", ".", "format", "(", "*", "*", "vars", "(", ")", ")", ")", "logger", ".", "debug", "(", "\"Writing temporary trajectory {tmptrj!r} (will be auto-cleaned).\"", ".", "format", "(", "*", "*", "vars", "(", ")", ")", ")", "sys", ".", "stdout", ".", "flush", "(", ")", "try", ":", "gromacs", ".", "trjconv", "(", "s", "=", "compact_structure", ",", "f", "=", "intrj", ",", "o", "=", "tmptrj", ",", "n", "=", "ndxcompact", ",", "ur", "=", "'compact'", ",", "center", "=", "True", ",", "boxcenter", "=", "'tric'", ",", "pbc", "=", "'mol'", ",", "input", "=", "inpcompact", ",", "*", "*", "kwargs", ")", "# explicitly set pbc=\"none\" for the fitting stage (anything else will produce rubbish and/or", "# complaints from Gromacs)", "kwargs", "[", "'pbc'", "]", "=", "\"none\"", "if", "compact_structure", "==", "fit_structure", ":", "# fit as ususal, including centering", "# (Is center=True really necessary? -- note, if I remove center=True then", "# I MUST fiddle inpfit as below!!)", "gromacs", ".", "trjconv", "(", "s", "=", "fit_structure", ",", "f", "=", "tmptrj", ",", "o", "=", "outtrj", ",", "n", "=", "ndx", ",", "fit", "=", "fitmode", ",", "center", "=", "True", ",", "input", "=", "inpfit", ",", "*", "*", "kwargs", ")", "else", ":", "# make sure that we fit EXACTLY as the user wants", "inpfit", "=", "[", "inpfit", "[", "0", "]", ",", "inpfit", "[", "-", "1", "]", "]", "gromacs", ".", "trjconv", "(", "s", "=", "fit_structure", ",", "f", "=", "tmptrj", ",", "o", "=", "outtrj", ",", "n", "=", "ndx", ",", "fit", "=", "fitmode", ",", "input", "=", "inpfit", ",", "*", "*", "kwargs", ")", "finally", ":", "utilities", ".", "unlink_gmx", "(", "tmptrj", ")" ]

[ "Center", "everything", "and", "make", "a", "compact", "representation", "(", "pass", "1", ")", "and", "fit", "the", "system", "to", "a", "reference", "(", "pass", "2", ")", "." ]

[ "def", "value", "(", "self", ")", ":", "return", "self", ".", "_ads", ".", "read", "(", "self", ".", "_pin_setting", ",", "is_differential", "=", "self", ".", "is_differential", ")" ]

[ "Returns", "the", "value", "of", "an", "ADC", "pin", "as", "an", "integer", "." ]

[ "def", "Relay", "(", "self", ",", "inventory", ")", ":", "if", "type", "(", "inventory", ")", "is", "MinerTransaction", ":", "return", "False", "if", "inventory", ".", "Hash", ".", "ToBytes", "(", ")", "in", "self", ".", "KnownHashes", ":", "return", "False", "self", ".", "KnownHashes", ".", "append", "(", "inventory", ".", "Hash", ".", "ToBytes", "(", ")", ")", "if", "type", "(", "inventory", ")", "is", "Block", ":", "pass", "elif", "type", "(", "inventory", ")", "is", "Transaction", "or", "issubclass", "(", "type", "(", "inventory", ")", ",", "Transaction", ")", ":", "if", "not", "self", ".", "AddTransaction", "(", "inventory", ")", ":", "# if we fail to add the transaction for whatever reason, remove it from the known hashes list or we cannot retry the same transaction again", "try", ":", "self", ".", "KnownHashes", ".", "remove", "(", "inventory", ".", "Hash", ".", "ToBytes", "(", ")", ")", "except", "ValueError", ":", "# it not found", "pass", "return", "False", "else", ":", "# consensus", "pass", "relayed", "=", "self", ".", "RelayDirectly", "(", "inventory", ")", "return", "relayed" ]

[ "Relay", "the", "inventory", "to", "the", "remote", "client", "." ]