Datasets:

kejian

/

codesearchnet-python-raw

like 1

[ "def", "bins", "(", "args", ")", ":", "from", "jcvi", ".", "formats", ".", "sizes", "import", "Sizes", "p", "=", "OptionParser", "(", "bins", ".", "__doc__", ")", "p", ".", "add_option", "(", "\"--binsize\"", ",", "default", "=", "100000", ",", "type", "=", "\"int\"", ",", "help", "=", "\"Size of the bins [default: %default]\"", ")", "p", ".", "add_option", "(", "\"--subtract\"", ",", "help", "=", "\"Subtract bases from window [default: %default]\"", ")", "p", ".", "add_option", "(", "\"--mode\"", ",", "default", "=", "\"span\"", ",", "choices", "=", "(", "\"span\"", ",", "\"count\"", ",", "\"score\"", ")", ",", "help", "=", "\"Accumulate feature based on [default: %default]\"", ")", "p", ".", "add_option", "(", "\"--nomerge\"", ",", "default", "=", "False", ",", "action", "=", "\"store_true\"", ",", "help", "=", "\"Do not merge features\"", ")", "opts", ",", "args", "=", "p", ".", "parse_args", "(", "args", ")", "if", "len", "(", "args", ")", "!=", "2", ":", "sys", ".", "exit", "(", "not", "p", ".", "print_help", "(", ")", ")", "bedfile", ",", "fastafile", "=", "args", "subtract", "=", "opts", ".", "subtract", "mode", "=", "opts", ".", "mode", "assert", "op", ".", "exists", "(", "bedfile", ")", ",", "\"File `{0}` not found\"", ".", "format", "(", "bedfile", ")", "binsize", "=", "opts", ".", "binsize", "binfile", "=", "bedfile", "+", "\".{0}\"", ".", "format", "(", "binsize", ")", "binfile", "+=", "\".{0}.bins\"", ".", "format", "(", "mode", ")", "if", "not", "need_update", "(", "bedfile", ",", "binfile", ")", ":", "return", "binfile", "sz", "=", "Sizes", "(", "fastafile", ")", "sizesfile", "=", "sz", ".", "filename", "sizes", "=", "sz", ".", "mapping", "fw", "=", "open", "(", "binfile", ",", "\"w\"", ")", "scores", "=", "\"median\"", "if", "mode", "==", "\"score\"", "else", "None", "if", "not", "opts", ".", "nomerge", ":", "bedfile", "=", "mergeBed", "(", "bedfile", ",", "nms", "=", "True", ",", "scores", "=", "scores", ")", "if", "subtract", ":", "subtractmerge", "=", "mergeBed", "(", "subtract", ")", "subtract_complement", "=", "complementBed", "(", "subtractmerge", ",", "sizesfile", ")", "bedfile", "=", "intersectBed", "(", "bedfile", ",", "subtract_complement", ")", "bedfile", "=", "sort", "(", "[", "bedfile", ",", "\"-i\"", "]", ")", "bed", "=", "Bed", "(", "bedfile", ")", "sbdict", "=", "dict", "(", "bed", ".", "sub_beds", "(", ")", ")", "for", "chr", ",", "chr_len", "in", "sorted", "(", "sizes", ".", "items", "(", ")", ")", ":", "chr_len", "=", "sizes", "[", "chr", "]", "subbeds", "=", "sbdict", ".", "get", "(", "chr", ",", "[", "]", ")", "nbins", "=", "chr_len", "/", "binsize", "last_bin", "=", "chr_len", "%", "binsize", "if", "last_bin", ":", "nbins", "+=", "1", "a", "=", "np", ".", "zeros", "(", "nbins", ")", "# values", "b", "=", "np", ".", "zeros", "(", "nbins", ",", "dtype", "=", "\"int\"", ")", "# bases", "c", "=", "np", ".", "zeros", "(", "nbins", ",", "dtype", "=", "\"int\"", ")", "# count", "b", "[", ":", "-", "1", "]", "=", "binsize", "b", "[", "-", "1", "]", "=", "last_bin", "for", "bb", "in", "subbeds", ":", "start", ",", "end", "=", "bb", ".", "start", ",", "bb", ".", "end", "startbin", "=", "start", "/", "binsize", "endbin", "=", "end", "/", "binsize", "assert", "startbin", "<=", "endbin", "c", "[", "startbin", ":", "endbin", "+", "1", "]", "+=", "1", "if", "mode", "==", "\"score\"", ":", "a", "[", "startbin", ":", "endbin", "+", "1", "]", "+=", "float", "(", "bb", ".", "score", ")", "elif", "mode", "==", "\"span\"", ":", "if", "startbin", "==", "endbin", ":", "a", "[", "startbin", "]", "+=", "end", "-", "start", "+", "1", "if", "startbin", "<", "endbin", ":", "firstsize", "=", "(", "startbin", "+", "1", ")", "*", "binsize", "-", "start", "+", "1", "lastsize", "=", "end", "-", "endbin", "*", "binsize", "a", "[", "startbin", "]", "+=", "firstsize", "if", "startbin", "+", "1", "<", "endbin", ":", "a", "[", "startbin", "+", "1", ":", "endbin", "]", "+=", "binsize", "a", "[", "endbin", "]", "+=", "lastsize", "if", "mode", "==", "\"count\"", ":", "a", "=", "c", "for", "xa", ",", "xb", "in", "zip", "(", "a", ",", "b", ")", ":", "print", "(", "\"\\t\"", ".", "join", "(", "str", "(", "x", ")", "for", "x", "in", "(", "chr", ",", "xa", ",", "xb", ")", ")", ",", "file", "=", "fw", ")", "fw", ".", "close", "(", ")", "if", "subtract", ":", "subtractbinfile", "=", "bins", "(", "[", "subtract", ",", "fastafile", ",", "\"--binsize={0}\"", ".", "format", "(", "binsize", ")", "]", ")", "binfile", "=", "subtractbins", "(", "binfile", ",", "subtractbinfile", ")", "return", "binfile" ]

[ "%prog", "bins", "bedfile", "fastafile" ]

[ "def", "fix_datagrepper_message", "(", "message", ")", ":", "if", "not", "(", "'source_name'", "in", "message", "and", "'source_version'", "in", "message", ")", ":", "return", "message", "# Don't mutate the original message", "message", "=", "message", ".", "copy", "(", ")", "del", "message", "[", "'source_name'", "]", "del", "message", "[", "'source_version'", "]", "# datanommer adds the headers field to the message in all cases.", "# This is a huge problem because if the signature was generated with a 'headers'", "# key set and we delete it here, messages will fail validation, but if we don't", "# messages will fail validation if they didn't have a 'headers' key set.", "#", "# There's no way to know whether or not the headers field was part of the signed", "# message or not. Generally, the problem is datanommer is mutating messages.", "if", "'headers'", "in", "message", "and", "not", "message", "[", "'headers'", "]", ":", "del", "message", "[", "'headers'", "]", "if", "'timestamp'", "in", "message", ":", "message", "[", "'timestamp'", "]", "=", "int", "(", "message", "[", "'timestamp'", "]", ")", "return", "message" ]

[ "See", "if", "a", "message", "is", "(", "probably", ")", "a", "datagrepper", "message", "and", "attempt", "to", "mutate", "it", "to", "pass", "signature", "validation", "." ]

[ "def", "regex_opt_inner", "(", "strings", ",", "open_paren", ")", ":", "close_paren", "=", "open_paren", "and", "')'", "or", "''", "# print strings, repr(open_paren)", "if", "not", "strings", ":", "# print '-> nothing left'", "return", "''", "first", "=", "strings", "[", "0", "]", "if", "len", "(", "strings", ")", "==", "1", ":", "# print '-> only 1 string'", "return", "open_paren", "+", "escape", "(", "first", ")", "+", "close_paren", "if", "not", "first", ":", "# print '-> first string empty'", "return", "open_paren", "+", "regex_opt_inner", "(", "strings", "[", "1", ":", "]", ",", "'(?:'", ")", "+", "'?'", "+", "close_paren", "if", "len", "(", "first", ")", "==", "1", ":", "# multiple one-char strings? make a charset", "oneletter", "=", "[", "]", "rest", "=", "[", "]", "for", "s", "in", "strings", ":", "if", "len", "(", "s", ")", "==", "1", ":", "oneletter", ".", "append", "(", "s", ")", "else", ":", "rest", ".", "append", "(", "s", ")", "if", "len", "(", "oneletter", ")", ">", "1", ":", "# do we have more than one oneletter string?", "if", "rest", ":", "# print '-> 1-character + rest'", "return", "open_paren", "+", "regex_opt_inner", "(", "rest", ",", "''", ")", "+", "'|'", "+", "make_charset", "(", "oneletter", ")", "+", "close_paren", "# print '-> only 1-character'", "return", "open_paren", "+", "make_charset", "(", "oneletter", ")", "+", "close_paren", "prefix", "=", "commonprefix", "(", "strings", ")", "if", "prefix", ":", "plen", "=", "len", "(", "prefix", ")", "# we have a prefix for all strings", "# print '-> prefix:', prefix", "return", "open_paren", "+", "escape", "(", "prefix", ")", "+", "regex_opt_inner", "(", "[", "s", "[", "plen", ":", "]", "for", "s", "in", "strings", "]", ",", "'(?:'", ")", "+", "close_paren", "# is there a suffix?", "strings_rev", "=", "[", "s", "[", ":", ":", "-", "1", "]", "for", "s", "in", "strings", "]", "suffix", "=", "commonprefix", "(", "strings_rev", ")", "if", "suffix", ":", "slen", "=", "len", "(", "suffix", ")", "# print '-> suffix:', suffix[::-1]", "return", "open_paren", "+", "regex_opt_inner", "(", "sorted", "(", "s", "[", ":", "-", "slen", "]", "for", "s", "in", "strings", ")", ",", "'(?:'", ")", "+", "escape", "(", "suffix", "[", ":", ":", "-", "1", "]", ")", "+", "close_paren", "# recurse on common 1-string prefixes", "# print '-> last resort'", "return", "open_paren", "+", "'|'", ".", "join", "(", "regex_opt_inner", "(", "list", "(", "group", "[", "1", "]", ")", ",", "''", ")", "for", "group", "in", "groupby", "(", "strings", ",", "lambda", "s", ":", "s", "[", "0", "]", "==", "first", "[", "0", "]", ")", ")", "+", "close_paren" ]

[ "Return", "a", "regex", "that", "matches", "any", "string", "in", "the", "sorted", "list", "of", "strings", "." ]

[ "def", "system_information", "(", ")", ":", "def", "system_version", "(", ")", ":", "'''\n Return host system version.\n '''", "lin_ver", "=", "linux_distribution", "(", ")", "mac_ver", "=", "platform", ".", "mac_ver", "(", ")", "win_ver", "=", "platform", ".", "win32_ver", "(", ")", "if", "lin_ver", "[", "0", "]", ":", "return", "' '", ".", "join", "(", "lin_ver", ")", "elif", "mac_ver", "[", "0", "]", ":", "if", "isinstance", "(", "mac_ver", "[", "1", "]", ",", "(", "tuple", ",", "list", ")", ")", "and", "''", ".", "join", "(", "mac_ver", "[", "1", "]", ")", ":", "return", "' '", ".", "join", "(", "[", "mac_ver", "[", "0", "]", ",", "'.'", ".", "join", "(", "mac_ver", "[", "1", "]", ")", ",", "mac_ver", "[", "2", "]", "]", ")", "else", ":", "return", "' '", ".", "join", "(", "[", "mac_ver", "[", "0", "]", ",", "mac_ver", "[", "2", "]", "]", ")", "elif", "win_ver", "[", "0", "]", ":", "return", "' '", ".", "join", "(", "win_ver", ")", "else", ":", "return", "''", "if", "platform", ".", "win32_ver", "(", ")", "[", "0", "]", ":", "# Get the version and release info based on the Windows Operating", "# System Product Name. As long as Microsoft maintains a similar format", "# this should be future proof", "import", "win32api", "# pylint: disable=3rd-party-module-not-gated", "import", "win32con", "# pylint: disable=3rd-party-module-not-gated", "# Get the product name from the registry", "hkey", "=", "win32con", ".", "HKEY_LOCAL_MACHINE", "key", "=", "'SOFTWARE\\\\Microsoft\\\\Windows NT\\\\CurrentVersion'", "value_name", "=", "'ProductName'", "reg_handle", "=", "win32api", ".", "RegOpenKey", "(", "hkey", ",", "key", ")", "# Returns a tuple of (product_name, value_type)", "product_name", ",", "_", "=", "win32api", ".", "RegQueryValueEx", "(", "reg_handle", ",", "value_name", ")", "version", "=", "'Unknown'", "release", "=", "''", "if", "'Server'", "in", "product_name", ":", "for", "item", "in", "product_name", ".", "split", "(", "' '", ")", ":", "# If it's all digits, then it's version", "if", "re", ".", "match", "(", "r'\\d+'", ",", "item", ")", ":", "version", "=", "item", "# If it starts with R and then numbers, it's the release", "# ie: R2", "if", "re", ".", "match", "(", "r'^R\\d+$'", ",", "item", ")", ":", "release", "=", "item", "release", "=", "'{0}Server{1}'", ".", "format", "(", "version", ",", "release", ")", "else", ":", "for", "item", "in", "product_name", ".", "split", "(", "' '", ")", ":", "# If it's a number, decimal number, Thin or Vista, then it's the", "# version", "if", "re", ".", "match", "(", "r'^(\\d+(\\.\\d+)?)|Thin|Vista$'", ",", "item", ")", ":", "version", "=", "item", "release", "=", "version", "_", ",", "ver", ",", "sp", ",", "extra", "=", "platform", ".", "win32_ver", "(", ")", "version", "=", "' '", ".", "join", "(", "[", "release", ",", "ver", ",", "sp", ",", "extra", "]", ")", "else", ":", "version", "=", "system_version", "(", ")", "release", "=", "platform", ".", "release", "(", ")", "system", "=", "[", "(", "'system'", ",", "platform", ".", "system", "(", ")", ")", ",", "(", "'dist'", ",", "' '", ".", "join", "(", "linux_distribution", "(", "full_distribution_name", "=", "False", ")", ")", ")", ",", "(", "'release'", ",", "release", ")", ",", "(", "'machine'", ",", "platform", ".", "machine", "(", ")", ")", ",", "(", "'version'", ",", "version", ")", ",", "(", "'locale'", ",", "__salt_system_encoding__", ")", ",", "]", "for", "name", ",", "attr", "in", "system", ":", "yield", "name", ",", "attr", "continue" ]

[ "Report", "system", "versions", "." ]

[ "def", "users_get_presence", "(", "self", ",", "user_id", "=", "None", ",", "username", "=", "None", ",", "*", "*", "kwargs", ")", ":", "if", "user_id", ":", "return", "self", ".", "__call_api_get", "(", "'users.getPresence'", ",", "userId", "=", "user_id", ",", "kwargs", "=", "kwargs", ")", "elif", "username", ":", "return", "self", ".", "__call_api_get", "(", "'users.getPresence'", ",", "username", "=", "username", ",", "kwargs", "=", "kwargs", ")", "else", ":", "raise", "RocketMissingParamException", "(", "'userID or username required'", ")" ]

[ "Gets", "the", "online", "presence", "of", "the", "a", "user", "." ]

[ "def", "walk_up_tree", "(", "root", ")", ":", "for", "child", "in", "root", ".", "children", ":", "for", "el", "in", "walk_up_tree", "(", "child", ")", ":", "yield", "el", "yield", "root" ]

[ "Post", "-", "order", "depth", "-", "first" ]

[ "def", "missing_property_names", "(", "self", ")", ":", "propname", "=", "lambda", "x", ":", "self", ".", "__prop_names__", "[", "x", "]", "missing", "=", "[", "]", "for", "x", "in", "self", ".", "__required__", ":", "# Allow the null type", "propinfo", "=", "self", ".", "propinfo", "(", "propname", "(", "x", ")", ")", "null_type", "=", "False", "if", "'type'", "in", "propinfo", ":", "type_info", "=", "propinfo", "[", "'type'", "]", "null_type", "=", "(", "type_info", "==", "'null'", "or", "isinstance", "(", "type_info", ",", "(", "list", ",", "tuple", ")", ")", "and", "'null'", "in", "type_info", ")", "elif", "'oneOf'", "in", "propinfo", ":", "for", "o", "in", "propinfo", "[", "'oneOf'", "]", ":", "type_info", "=", "o", ".", "get", "(", "'type'", ")", "if", "type_info", "and", "type_info", "==", "'null'", "or", "isinstance", "(", "type_info", ",", "(", "list", ",", "tuple", ")", ")", "and", "'null'", "in", "type_info", ":", "null_type", "=", "True", "break", "if", "(", "propname", "(", "x", ")", "not", "in", "self", ".", "_properties", "and", "null_type", ")", "or", "(", "self", ".", "_properties", "[", "propname", "(", "x", ")", "]", "is", "None", "and", "not", "null_type", ")", ":", "missing", ".", "append", "(", "x", ")", "return", "missing" ]

[ "Returns", "a", "list", "of", "properties", "which", "are", "required", "and", "missing", "." ]

[ "def", "create", "(", "fs", ",", "channels", ")", ":", "result_code", "=", "ctypes", ".", "c_int", "(", ")", "result", "=", "_create", "(", "fs", ",", "channels", ",", "ctypes", ".", "byref", "(", "result_code", ")", ")", "if", "result_code", ".", "value", "is", "not", "0", ":", "raise", "OpusError", "(", "result_code", ".", "value", ")", "return", "result" ]

[ "Allocates", "and", "initializes", "a", "decoder", "state" ]

[ "def", "circle", "(", "self", ",", "x", ",", "y", ",", "diameter", ",", "draw", "=", "True", ",", "*", "*", "kwargs", ")", ":", "return", "self", ".", "ellipse", "(", "x", ",", "y", ",", "diameter", ",", "diameter", ",", "draw", ",", "*", "*", "kwargs", ")" ]

[ "Draw", "a", "circle", ":", "param", "x", ":", "x", "-", "coordinate", "of", "the", "top", "left", "corner", ":", "param", "y", ":", "y", "-", "coordinate", "of", "the", "top", "left", "corner", ":", "param", "diameter", ":", "Diameter", "of", "circle", ".", ":", "param", "draw", ":", "Draw", "immediately", "(", "defaults", "to", "True", "set", "to", "False", "to", "inhibit", "drawing", ")", ":", "return", ":", "Path", "object", "representing", "circle" ]

[ "def", "save_four_ds9", "(", "rectwv_coeff", ",", "debugplot", "=", "0", ")", ":", "for", "limits", ",", "rectified", ",", "suffix", "in", "zip", "(", "[", "'frontiers'", ",", "'frontiers'", ",", "'boundaries'", ",", "'boundaries'", "]", ",", "[", "False", ",", "True", ",", "False", ",", "True", "]", ",", "[", "'rawimage'", ",", "'rectified'", ",", "'rawimage'", ",", "'rectified'", "]", ")", ":", "output", "=", "rectwv_coeff_to_ds9", "(", "rectwv_coeff", "=", "rectwv_coeff", ",", "limits", "=", "limits", ",", "rectified", "=", "rectified", ")", "filename", "=", "'ds9_'", "+", "limits", "+", "'_'", "+", "suffix", "+", "'.reg'", "if", "abs", "(", "debugplot", ")", ">=", "10", ":", "print", "(", "'>>> Saving: '", ",", "filename", ")", "save_ds9", "(", "output", ",", "filename", ")" ]

[ "Save", "the", "4", "possible", "ds9", "region", "files", "." ]

[ "def", "apply_sfr_obs", "(", ")", ":", "assert", "os", ".", "path", ".", "exists", "(", "\"sfr_obs.config\"", ")", "df_key", "=", "pd", ".", "read_csv", "(", "\"sfr_obs.config\"", ",", "index_col", "=", "0", ")", "assert", "df_key", ".", "iloc", "[", "0", ",", "0", "]", "==", "\"sfr_out_file\"", ",", "df_key", ".", "iloc", "[", "0", ",", ":", "]", "sfr_out_file", "=", "df_key", ".", "iloc", "[", "0", ",", "1", "]", "df_key", "=", "df_key", ".", "iloc", "[", "1", ":", ",", ":", "]", "df_key", ".", "loc", "[", ":", ",", "\"segment\"", "]", "=", "df_key", ".", "segment", ".", "apply", "(", "np", ".", "int", ")", "df_key", ".", "index", "=", "df_key", ".", "segment", "seg_group_dict", "=", "df_key", ".", "groupby", "(", "df_key", ".", "obs_base", ")", ".", "groups", "sfr_kper", "=", "load_sfr_out", "(", "sfr_out_file", ")", "kpers", "=", "list", "(", "sfr_kper", ".", "keys", "(", ")", ")", "kpers", ".", "sort", "(", ")", "#results = {o:[] for o in seg_group_dict.keys()}", "results", "=", "[", "]", "for", "kper", "in", "kpers", ":", "df", "=", "sfr_kper", "[", "kper", "]", "for", "obs_base", ",", "segs", "in", "seg_group_dict", ".", "items", "(", ")", ":", "agg", "=", "df", ".", "loc", "[", "segs", ".", "values", ",", ":", "]", ".", "sum", "(", ")", "# still agg flout where seg groups are passed!", "#print(obs_base,agg)", "results", ".", "append", "(", "[", "kper", ",", "obs_base", ",", "agg", "[", "\"flaqx\"", "]", ",", "agg", "[", "\"flout\"", "]", "]", ")", "df", "=", "pd", ".", "DataFrame", "(", "data", "=", "results", ",", "columns", "=", "[", "\"kper\"", ",", "\"obs_base\"", ",", "\"flaqx\"", ",", "\"flout\"", "]", ")", "df", ".", "sort_values", "(", "by", "=", "[", "\"kper\"", ",", "\"obs_base\"", "]", ",", "inplace", "=", "True", ")", "df", ".", "to_csv", "(", "sfr_out_file", "+", "\".processed\"", ",", "sep", "=", "' '", ",", "index", "=", "False", ")", "return", "df" ]

[ "apply", "the", "sfr", "observation", "process", "-", "pairs", "with", "setup_sfr_obs", "()", ".", "requires", "sfr_obs", ".", "config", ".", "Writes", "<sfr_out_file", ">", ".", "processed", "where", "<sfr_out_file", ">", "is", "defined", "in", "sfr_obs", ".", "config" ]

[ "def", "register_transformer", "(", "self", ",", "transformer", ")", ":", "if", "transformer", "not", "in", "self", ".", "_transformers", ":", "self", ".", "_transformers", ".", "append", "(", "transformer", ")", "self", ".", "sort_transformers", "(", ")" ]

[ "Register", "a", "transformer", "instance", "." ]

[ "def", "cleanPath", "(", "element", ",", "options", ")", ":", "global", "_num_bytes_saved_in_path_data", "global", "_num_path_segments_removed", "# this gets the parser object from svg_regex.py", "oldPathStr", "=", "element", ".", "getAttribute", "(", "'d'", ")", "path", "=", "svg_parser", ".", "parse", "(", "oldPathStr", ")", "style", "=", "_getStyle", "(", "element", ")", "# This determines whether the stroke has round or square linecaps. If it does, we do not want to collapse empty", "# segments, as they are actually rendered (as circles or squares with diameter/dimension matching the path-width).", "has_round_or_square_linecaps", "=", "(", "element", ".", "getAttribute", "(", "'stroke-linecap'", ")", "in", "[", "'round'", ",", "'square'", "]", "or", "'stroke-linecap'", "in", "style", "and", "style", "[", "'stroke-linecap'", "]", "in", "[", "'round'", ",", "'square'", "]", ")", "# This determines whether the stroke has intermediate markers. If it does, we do not want to collapse", "# straight segments running in the same direction, as markers are rendered on the intermediate nodes.", "has_intermediate_markers", "=", "(", "element", ".", "hasAttribute", "(", "'marker'", ")", "or", "element", ".", "hasAttribute", "(", "'marker-mid'", ")", "or", "'marker'", "in", "style", "or", "'marker-mid'", "in", "style", ")", "# The first command must be a moveto, and whether it's relative (m)", "# or absolute (M), the first set of coordinates *is* absolute. So", "# the first iteration of the loop below will get x,y and startx,starty.", "# convert absolute coordinates into relative ones.", "# Reuse the data structure 'path', since we're not adding or removing subcommands.", "# Also reuse the coordinate lists since we're not adding or removing any.", "x", "=", "y", "=", "0", "for", "pathIndex", "in", "range", "(", "len", "(", "path", ")", ")", ":", "cmd", ",", "data", "=", "path", "[", "pathIndex", "]", "# Changes to cmd don't get through to the data structure", "i", "=", "0", "# adjust abs to rel", "# only the A command has some values that we don't want to adjust (radii, rotation, flags)", "if", "cmd", "==", "'A'", ":", "for", "i", "in", "range", "(", "i", ",", "len", "(", "data", ")", ",", "7", ")", ":", "data", "[", "i", "+", "5", "]", "-=", "x", "data", "[", "i", "+", "6", "]", "-=", "y", "x", "+=", "data", "[", "i", "+", "5", "]", "y", "+=", "data", "[", "i", "+", "6", "]", "path", "[", "pathIndex", "]", "=", "(", "'a'", ",", "data", ")", "elif", "cmd", "==", "'a'", ":", "x", "+=", "sum", "(", "data", "[", "5", ":", ":", "7", "]", ")", "y", "+=", "sum", "(", "data", "[", "6", ":", ":", "7", "]", ")", "elif", "cmd", "==", "'H'", ":", "for", "i", "in", "range", "(", "i", ",", "len", "(", "data", ")", ")", ":", "data", "[", "i", "]", "-=", "x", "x", "+=", "data", "[", "i", "]", "path", "[", "pathIndex", "]", "=", "(", "'h'", ",", "data", ")", "elif", "cmd", "==", "'h'", ":", "x", "+=", "sum", "(", "data", ")", "elif", "cmd", "==", "'V'", ":", "for", "i", "in", "range", "(", "i", ",", "len", "(", "data", ")", ")", ":", "data", "[", "i", "]", "-=", "y", "y", "+=", "data", "[", "i", "]", "path", "[", "pathIndex", "]", "=", "(", "'v'", ",", "data", ")", "elif", "cmd", "==", "'v'", ":", "y", "+=", "sum", "(", "data", ")", "elif", "cmd", "==", "'M'", ":", "startx", ",", "starty", "=", "data", "[", "0", "]", ",", "data", "[", "1", "]", "# If this is a path starter, don't convert its first", "# coordinate to relative; that would just make it (0, 0)", "if", "pathIndex", "!=", "0", ":", "data", "[", "0", "]", "-=", "x", "data", "[", "1", "]", "-=", "y", "x", ",", "y", "=", "startx", ",", "starty", "i", "=", "2", "for", "i", "in", "range", "(", "i", ",", "len", "(", "data", ")", ",", "2", ")", ":", "data", "[", "i", "]", "-=", "x", "data", "[", "i", "+", "1", "]", "-=", "y", "x", "+=", "data", "[", "i", "]", "y", "+=", "data", "[", "i", "+", "1", "]", "path", "[", "pathIndex", "]", "=", "(", "'m'", ",", "data", ")", "elif", "cmd", "in", "[", "'L'", ",", "'T'", "]", ":", "for", "i", "in", "range", "(", "i", ",", "len", "(", "data", ")", ",", "2", ")", ":", "data", "[", "i", "]", "-=", "x", "data", "[", "i", "+", "1", "]", "-=", "y", "x", "+=", "data", "[", "i", "]", "y", "+=", "data", "[", "i", "+", "1", "]", "path", "[", "pathIndex", "]", "=", "(", "cmd", ".", "lower", "(", ")", ",", "data", ")", "elif", "cmd", "in", "[", "'m'", "]", ":", "if", "pathIndex", "==", "0", ":", "# START OF PATH - this is an absolute moveto", "# followed by relative linetos", "startx", ",", "starty", "=", "data", "[", "0", "]", ",", "data", "[", "1", "]", "x", ",", "y", "=", "startx", ",", "starty", "i", "=", "2", "else", ":", "startx", "=", "x", "+", "data", "[", "0", "]", "starty", "=", "y", "+", "data", "[", "1", "]", "for", "i", "in", "range", "(", "i", ",", "len", "(", "data", ")", ",", "2", ")", ":", "x", "+=", "data", "[", "i", "]", "y", "+=", "data", "[", "i", "+", "1", "]", "elif", "cmd", "in", "[", "'l'", ",", "'t'", "]", ":", "x", "+=", "sum", "(", "data", "[", "0", ":", ":", "2", "]", ")", "y", "+=", "sum", "(", "data", "[", "1", ":", ":", "2", "]", ")", "elif", "cmd", "in", "[", "'S'", ",", "'Q'", "]", ":", "for", "i", "in", "range", "(", "i", ",", "len", "(", "data", ")", ",", "4", ")", ":", "data", "[", "i", "]", "-=", "x", "data", "[", "i", "+", "1", "]", "-=", "y", "data", "[", "i", "+", "2", "]", "-=", "x", "data", "[", "i", "+", "3", "]", "-=", "y", "x", "+=", "data", "[", "i", "+", "2", "]", "y", "+=", "data", "[", "i", "+", "3", "]", "path", "[", "pathIndex", "]", "=", "(", "cmd", ".", "lower", "(", ")", ",", "data", ")", "elif", "cmd", "in", "[", "'s'", ",", "'q'", "]", ":", "x", "+=", "sum", "(", "data", "[", "2", ":", ":", "4", "]", ")", "y", "+=", "sum", "(", "data", "[", "3", ":", ":", "4", "]", ")", "elif", "cmd", "==", "'C'", ":", "for", "i", "in", "range", "(", "i", ",", "len", "(", "data", ")", ",", "6", ")", ":", "data", "[", "i", "]", "-=", "x", "data", "[", "i", "+", "1", "]", "-=", "y", "data", "[", "i", "+", "2", "]", "-=", "x", "data", "[", "i", "+", "3", "]", "-=", "y", "data", "[", "i", "+", "4", "]", "-=", "x", "data", "[", "i", "+", "5", "]", "-=", "y", "x", "+=", "data", "[", "i", "+", "4", "]", "y", "+=", "data", "[", "i", "+", "5", "]", "path", "[", "pathIndex", "]", "=", "(", "'c'", ",", "data", ")", "elif", "cmd", "==", "'c'", ":", "x", "+=", "sum", "(", "data", "[", "4", ":", ":", "6", "]", ")", "y", "+=", "sum", "(", "data", "[", "5", ":", ":", "6", "]", ")", "elif", "cmd", "in", "[", "'z'", ",", "'Z'", "]", ":", "x", ",", "y", "=", "startx", ",", "starty", "path", "[", "pathIndex", "]", "=", "(", "'z'", ",", "data", ")", "# remove empty segments and redundant commands", "# Reuse the data structure 'path' and the coordinate lists, even if we're", "# deleting items, because these deletions are relatively cheap.", "if", "not", "has_round_or_square_linecaps", ":", "# remove empty path segments", "for", "pathIndex", "in", "range", "(", "len", "(", "path", ")", ")", ":", "cmd", ",", "data", "=", "path", "[", "pathIndex", "]", "i", "=", "0", "if", "cmd", "in", "[", "'m'", ",", "'l'", ",", "'t'", "]", ":", "if", "cmd", "==", "'m'", ":", "# It might be tempting to rewrite \"m0 0 ...\" into", "# \"l...\" here. However, this is an unsound", "# optimization in general as \"m0 0 ... z\" is", "# different from \"l...z\".", "#", "# To do such a rewrite, we need to understand the", "# full subpath. This logic happens after this", "# loop.", "i", "=", "2", "while", "i", "<", "len", "(", "data", ")", ":", "if", "data", "[", "i", "]", "==", "data", "[", "i", "+", "1", "]", "==", "0", ":", "del", "data", "[", "i", ":", "i", "+", "2", "]", "_num_path_segments_removed", "+=", "1", "else", ":", "i", "+=", "2", "elif", "cmd", "==", "'c'", ":", "while", "i", "<", "len", "(", "data", ")", ":", "if", "data", "[", "i", "]", "==", "data", "[", "i", "+", "1", "]", "==", "data", "[", "i", "+", "2", "]", "==", "data", "[", "i", "+", "3", "]", "==", "data", "[", "i", "+", "4", "]", "==", "data", "[", "i", "+", "5", "]", "==", "0", ":", "del", "data", "[", "i", ":", "i", "+", "6", "]", "_num_path_segments_removed", "+=", "1", "else", ":", "i", "+=", "6", "elif", "cmd", "==", "'a'", ":", "while", "i", "<", "len", "(", "data", ")", ":", "if", "data", "[", "i", "+", "5", "]", "==", "data", "[", "i", "+", "6", "]", "==", "0", ":", "del", "data", "[", "i", ":", "i", "+", "7", "]", "_num_path_segments_removed", "+=", "1", "else", ":", "i", "+=", "7", "elif", "cmd", "==", "'q'", ":", "while", "i", "<", "len", "(", "data", ")", ":", "if", "data", "[", "i", "]", "==", "data", "[", "i", "+", "1", "]", "==", "data", "[", "i", "+", "2", "]", "==", "data", "[", "i", "+", "3", "]", "==", "0", ":", "del", "data", "[", "i", ":", "i", "+", "4", "]", "_num_path_segments_removed", "+=", "1", "else", ":", "i", "+=", "4", "elif", "cmd", "in", "[", "'h'", ",", "'v'", "]", ":", "oldLen", "=", "len", "(", "data", ")", "path", "[", "pathIndex", "]", "=", "(", "cmd", ",", "[", "coord", "for", "coord", "in", "data", "if", "coord", "!=", "0", "]", ")", "_num_path_segments_removed", "+=", "len", "(", "path", "[", "pathIndex", "]", "[", "1", "]", ")", "-", "oldLen", "# remove no-op commands", "pathIndex", "=", "len", "(", "path", ")", "subpath_needs_anchor", "=", "False", "# NB: We can never rewrite the first m/M command (expect if it", "# is the only command)", "while", "pathIndex", ">", "1", ":", "pathIndex", "-=", "1", "cmd", ",", "data", "=", "path", "[", "pathIndex", "]", "if", "cmd", "==", "'z'", ":", "next_cmd", ",", "next_data", "=", "path", "[", "pathIndex", "-", "1", "]", "if", "next_cmd", "==", "'m'", "and", "len", "(", "next_data", ")", "==", "2", ":", "# mX Yz -> mX Y", "# note the len check on next_data as it is not", "# safe to rewrite \"m0 0 1 1z\" in general (it is a", "# question of where the \"pen\" ends - you can", "# continue a draw on the same subpath after a", "# \"z\").", "del", "path", "[", "pathIndex", "]", "_num_path_segments_removed", "+=", "1", "else", ":", "# it is not safe to rewrite \"m0 0 ...\" to \"l...\"", "# because of this \"z\" command.", "subpath_needs_anchor", "=", "True", "elif", "cmd", "==", "'m'", ":", "if", "len", "(", "path", ")", "-", "1", "==", "pathIndex", "and", "len", "(", "data", ")", "==", "2", ":", "# Ends with an empty move (but no line/draw", "# following it)", "del", "path", "[", "pathIndex", "]", "_num_path_segments_removed", "+=", "1", "continue", "if", "subpath_needs_anchor", ":", "subpath_needs_anchor", "=", "False", "elif", "data", "[", "0", "]", "==", "data", "[", "1", "]", "==", "0", ":", "# unanchored, i.e. we can replace \"m0 0 ...\" with", "# \"l...\" as there is no \"z\" after it.", "path", "[", "pathIndex", "]", "=", "(", "'l'", ",", "data", "[", "2", ":", "]", ")", "_num_path_segments_removed", "+=", "1", "# fixup: Delete subcommands having no coordinates.", "path", "=", "[", "elem", "for", "elem", "in", "path", "if", "len", "(", "elem", "[", "1", "]", ")", ">", "0", "or", "elem", "[", "0", "]", "==", "'z'", "]", "# convert straight curves into lines", "newPath", "=", "[", "path", "[", "0", "]", "]", "for", "(", "cmd", ",", "data", ")", "in", "path", "[", "1", ":", "]", ":", "i", "=", "0", "newData", "=", "data", "if", "cmd", "==", "'c'", ":", "newData", "=", "[", "]", "while", "i", "<", "len", "(", "data", ")", ":", "# since all commands are now relative, we can think of previous point as (0,0)", "# and new point (dx,dy) is (data[i+4],data[i+5])", "# eqn of line will be y = (dy/dx)*x or if dx=0 then eqn of line is x=0", "(", "p1x", ",", "p1y", ")", "=", "(", "data", "[", "i", "]", ",", "data", "[", "i", "+", "1", "]", ")", "(", "p2x", ",", "p2y", ")", "=", "(", "data", "[", "i", "+", "2", "]", ",", "data", "[", "i", "+", "3", "]", ")", "dx", "=", "data", "[", "i", "+", "4", "]", "dy", "=", "data", "[", "i", "+", "5", "]", "foundStraightCurve", "=", "False", "if", "dx", "==", "0", ":", "if", "p1x", "==", "0", "and", "p2x", "==", "0", ":", "foundStraightCurve", "=", "True", "else", ":", "m", "=", "dy", "/", "dx", "if", "p1y", "==", "m", "*", "p1x", "and", "p2y", "==", "m", "*", "p2x", ":", "foundStraightCurve", "=", "True", "if", "foundStraightCurve", ":", "# flush any existing curve coords first", "if", "newData", ":", "newPath", ".", "append", "(", "(", "cmd", ",", "newData", ")", ")", "newData", "=", "[", "]", "# now create a straight line segment", "newPath", ".", "append", "(", "(", "'l'", ",", "[", "dx", ",", "dy", "]", ")", ")", "else", ":", "newData", ".", "extend", "(", "data", "[", "i", ":", "i", "+", "6", "]", ")", "i", "+=", "6", "if", "newData", "or", "cmd", "==", "'z'", "or", "cmd", "==", "'Z'", ":", "newPath", ".", "append", "(", "(", "cmd", ",", "newData", ")", ")", "path", "=", "newPath", "# collapse all consecutive commands of the same type into one command", "prevCmd", "=", "''", "prevData", "=", "[", "]", "newPath", "=", "[", "]", "for", "(", "cmd", ",", "data", ")", "in", "path", ":", "if", "prevCmd", "==", "''", ":", "# initialize with current path cmd and data", "prevCmd", "=", "cmd", "prevData", "=", "data", "else", ":", "# collapse if", "# - cmd is not moveto (explicit moveto commands are not drawn)", "# - the previous and current commands are the same type,", "# - the previous command is moveto and the current is lineto", "# (subsequent moveto pairs are treated as implicit lineto commands)", "if", "cmd", "!=", "'m'", "and", "(", "cmd", "==", "prevCmd", "or", "(", "cmd", "==", "'l'", "and", "prevCmd", "==", "'m'", ")", ")", ":", "prevData", ".", "extend", "(", "data", ")", "# else flush the previous command if it is not the same type as the current command", "else", ":", "newPath", ".", "append", "(", "(", "prevCmd", ",", "prevData", ")", ")", "prevCmd", "=", "cmd", "prevData", "=", "data", "# flush last command and data", "newPath", ".", "append", "(", "(", "prevCmd", ",", "prevData", ")", ")", "path", "=", "newPath", "# convert to shorthand path segments where possible", "newPath", "=", "[", "]", "for", "(", "cmd", ",", "data", ")", "in", "path", ":", "# convert line segments into h,v where possible", "if", "cmd", "==", "'l'", ":", "i", "=", "0", "lineTuples", "=", "[", "]", "while", "i", "<", "len", "(", "data", ")", ":", "if", "data", "[", "i", "]", "==", "0", ":", "# vertical", "if", "lineTuples", ":", "# flush the existing line command", "newPath", ".", "append", "(", "(", "'l'", ",", "lineTuples", ")", ")", "lineTuples", "=", "[", "]", "# append the v and then the remaining line coords", "newPath", ".", "append", "(", "(", "'v'", ",", "[", "data", "[", "i", "+", "1", "]", "]", ")", ")", "_num_path_segments_removed", "+=", "1", "elif", "data", "[", "i", "+", "1", "]", "==", "0", ":", "if", "lineTuples", ":", "# flush the line command, then append the h and then the remaining line coords", "newPath", ".", "append", "(", "(", "'l'", ",", "lineTuples", ")", ")", "lineTuples", "=", "[", "]", "newPath", ".", "append", "(", "(", "'h'", ",", "[", "data", "[", "i", "]", "]", ")", ")", "_num_path_segments_removed", "+=", "1", "else", ":", "lineTuples", ".", "extend", "(", "data", "[", "i", ":", "i", "+", "2", "]", ")", "i", "+=", "2", "if", "lineTuples", ":", "newPath", ".", "append", "(", "(", "'l'", ",", "lineTuples", ")", ")", "# also handle implied relative linetos", "elif", "cmd", "==", "'m'", ":", "i", "=", "2", "lineTuples", "=", "[", "data", "[", "0", "]", ",", "data", "[", "1", "]", "]", "while", "i", "<", "len", "(", "data", ")", ":", "if", "data", "[", "i", "]", "==", "0", ":", "# vertical", "if", "lineTuples", ":", "# flush the existing m/l command", "newPath", ".", "append", "(", "(", "cmd", ",", "lineTuples", ")", ")", "lineTuples", "=", "[", "]", "cmd", "=", "'l'", "# dealing with linetos now", "# append the v and then the remaining line coords", "newPath", ".", "append", "(", "(", "'v'", ",", "[", "data", "[", "i", "+", "1", "]", "]", ")", ")", "_num_path_segments_removed", "+=", "1", "elif", "data", "[", "i", "+", "1", "]", "==", "0", ":", "if", "lineTuples", ":", "# flush the m/l command, then append the h and then the remaining line coords", "newPath", ".", "append", "(", "(", "cmd", ",", "lineTuples", ")", ")", "lineTuples", "=", "[", "]", "cmd", "=", "'l'", "# dealing with linetos now", "newPath", ".", "append", "(", "(", "'h'", ",", "[", "data", "[", "i", "]", "]", ")", ")", "_num_path_segments_removed", "+=", "1", "else", ":", "lineTuples", ".", "extend", "(", "data", "[", "i", ":", "i", "+", "2", "]", ")", "i", "+=", "2", "if", "lineTuples", ":", "newPath", ".", "append", "(", "(", "cmd", ",", "lineTuples", ")", ")", "# convert Bézier curve segments into s where possible", "elif", "cmd", "==", "'c'", ":", "# set up the assumed bezier control point as the current point,", "# i.e. (0,0) since we're using relative coords", "bez_ctl_pt", "=", "(", "0", ",", "0", ")", "# however if the previous command was 's'", "# the assumed control point is a reflection of the previous control point at the current point", "if", "len", "(", "newPath", ")", ":", "(", "prevCmd", ",", "prevData", ")", "=", "newPath", "[", "-", "1", "]", "if", "prevCmd", "==", "'s'", ":", "bez_ctl_pt", "=", "(", "prevData", "[", "-", "2", "]", "-", "prevData", "[", "-", "4", "]", ",", "prevData", "[", "-", "1", "]", "-", "prevData", "[", "-", "3", "]", ")", "i", "=", "0", "curveTuples", "=", "[", "]", "while", "i", "<", "len", "(", "data", ")", ":", "# rotate by 180deg means negate both coordinates", "# if the previous control point is equal then we can substitute a", "# shorthand bezier command", "if", "bez_ctl_pt", "[", "0", "]", "==", "data", "[", "i", "]", "and", "bez_ctl_pt", "[", "1", "]", "==", "data", "[", "i", "+", "1", "]", ":", "if", "curveTuples", ":", "newPath", ".", "append", "(", "(", "'c'", ",", "curveTuples", ")", ")", "curveTuples", "=", "[", "]", "# append the s command", "newPath", ".", "append", "(", "(", "'s'", ",", "[", "data", "[", "i", "+", "2", "]", ",", "data", "[", "i", "+", "3", "]", ",", "data", "[", "i", "+", "4", "]", ",", "data", "[", "i", "+", "5", "]", "]", ")", ")", "_num_path_segments_removed", "+=", "1", "else", ":", "j", "=", "0", "while", "j", "<=", "5", ":", "curveTuples", ".", "append", "(", "data", "[", "i", "+", "j", "]", ")", "j", "+=", "1", "# set up control point for next curve segment", "bez_ctl_pt", "=", "(", "data", "[", "i", "+", "4", "]", "-", "data", "[", "i", "+", "2", "]", ",", "data", "[", "i", "+", "5", "]", "-", "data", "[", "i", "+", "3", "]", ")", "i", "+=", "6", "if", "curveTuples", ":", "newPath", ".", "append", "(", "(", "'c'", ",", "curveTuples", ")", ")", "# convert quadratic curve segments into t where possible", "elif", "cmd", "==", "'q'", ":", "quad_ctl_pt", "=", "(", "0", ",", "0", ")", "i", "=", "0", "curveTuples", "=", "[", "]", "while", "i", "<", "len", "(", "data", ")", ":", "if", "quad_ctl_pt", "[", "0", "]", "==", "data", "[", "i", "]", "and", "quad_ctl_pt", "[", "1", "]", "==", "data", "[", "i", "+", "1", "]", ":", "if", "curveTuples", ":", "newPath", ".", "append", "(", "(", "'q'", ",", "curveTuples", ")", ")", "curveTuples", "=", "[", "]", "# append the t command", "newPath", ".", "append", "(", "(", "'t'", ",", "[", "data", "[", "i", "+", "2", "]", ",", "data", "[", "i", "+", "3", "]", "]", ")", ")", "_num_path_segments_removed", "+=", "1", "else", ":", "j", "=", "0", "while", "j", "<=", "3", ":", "curveTuples", ".", "append", "(", "data", "[", "i", "+", "j", "]", ")", "j", "+=", "1", "quad_ctl_pt", "=", "(", "data", "[", "i", "+", "2", "]", "-", "data", "[", "i", "]", ",", "data", "[", "i", "+", "3", "]", "-", "data", "[", "i", "+", "1", "]", ")", "i", "+=", "4", "if", "curveTuples", ":", "newPath", ".", "append", "(", "(", "'q'", ",", "curveTuples", ")", ")", "else", ":", "newPath", ".", "append", "(", "(", "cmd", ",", "data", ")", ")", "path", "=", "newPath", "# For each m, l, h or v, collapse unnecessary coordinates that run in the same direction", "# i.e. \"h-100-100\" becomes \"h-200\" but \"h300-100\" does not change.", "# If the path has intermediate markers we have to preserve intermediate nodes, though.", "# Reuse the data structure 'path', since we're not adding or removing subcommands.", "# Also reuse the coordinate lists, even if we're deleting items, because these", "# deletions are relatively cheap.", "if", "not", "has_intermediate_markers", ":", "for", "pathIndex", "in", "range", "(", "len", "(", "path", ")", ")", ":", "cmd", ",", "data", "=", "path", "[", "pathIndex", "]", "# h / v expects only one parameter and we start drawing with the first (so we need at least 2)", "if", "cmd", "in", "[", "'h'", ",", "'v'", "]", "and", "len", "(", "data", ")", ">=", "2", ":", "coordIndex", "=", "0", "while", "coordIndex", "+", "1", "<", "len", "(", "data", ")", ":", "if", "is_same_sign", "(", "data", "[", "coordIndex", "]", ",", "data", "[", "coordIndex", "+", "1", "]", ")", ":", "data", "[", "coordIndex", "]", "+=", "data", "[", "coordIndex", "+", "1", "]", "del", "data", "[", "coordIndex", "+", "1", "]", "_num_path_segments_removed", "+=", "1", "else", ":", "coordIndex", "+=", "1", "# l expects two parameters and we start drawing with the first (so we need at least 4)", "elif", "cmd", "==", "'l'", "and", "len", "(", "data", ")", ">=", "4", ":", "coordIndex", "=", "0", "while", "coordIndex", "+", "2", "<", "len", "(", "data", ")", ":", "if", "is_same_direction", "(", "*", "data", "[", "coordIndex", ":", "coordIndex", "+", "4", "]", ")", ":", "data", "[", "coordIndex", "]", "+=", "data", "[", "coordIndex", "+", "2", "]", "data", "[", "coordIndex", "+", "1", "]", "+=", "data", "[", "coordIndex", "+", "3", "]", "del", "data", "[", "coordIndex", "+", "2", "]", "# delete the next two elements", "del", "data", "[", "coordIndex", "+", "2", "]", "_num_path_segments_removed", "+=", "1", "else", ":", "coordIndex", "+=", "2", "# m expects two parameters but we have to skip the first pair as it's not drawn (so we need at least 6)", "elif", "cmd", "==", "'m'", "and", "len", "(", "data", ")", ">=", "6", ":", "coordIndex", "=", "2", "while", "coordIndex", "+", "2", "<", "len", "(", "data", ")", ":", "if", "is_same_direction", "(", "*", "data", "[", "coordIndex", ":", "coordIndex", "+", "4", "]", ")", ":", "data", "[", "coordIndex", "]", "+=", "data", "[", "coordIndex", "+", "2", "]", "data", "[", "coordIndex", "+", "1", "]", "+=", "data", "[", "coordIndex", "+", "3", "]", "del", "data", "[", "coordIndex", "+", "2", "]", "# delete the next two elements", "del", "data", "[", "coordIndex", "+", "2", "]", "_num_path_segments_removed", "+=", "1", "else", ":", "coordIndex", "+=", "2", "# it is possible that we have consecutive h, v, c, t commands now", "# so again collapse all consecutive commands of the same type into one command", "prevCmd", "=", "''", "prevData", "=", "[", "]", "newPath", "=", "[", "path", "[", "0", "]", "]", "for", "(", "cmd", ",", "data", ")", "in", "path", "[", "1", ":", "]", ":", "# flush the previous command if it is not the same type as the current command", "if", "prevCmd", "!=", "''", ":", "if", "cmd", "!=", "prevCmd", "or", "cmd", "==", "'m'", ":", "newPath", ".", "append", "(", "(", "prevCmd", ",", "prevData", ")", ")", "prevCmd", "=", "''", "prevData", "=", "[", "]", "# if the previous and current commands are the same type, collapse", "if", "cmd", "==", "prevCmd", "and", "cmd", "!=", "'m'", ":", "prevData", ".", "extend", "(", "data", ")", "# save last command and data", "else", ":", "prevCmd", "=", "cmd", "prevData", "=", "data", "# flush last command and data", "if", "prevCmd", "!=", "''", ":", "newPath", ".", "append", "(", "(", "prevCmd", ",", "prevData", ")", ")", "path", "=", "newPath", "newPathStr", "=", "serializePath", "(", "path", ",", "options", ")", "# if for whatever reason we actually made the path longer don't use it", "# TODO: maybe we could compare path lengths after each optimization step and use the shortest", "if", "len", "(", "newPathStr", ")", "<=", "len", "(", "oldPathStr", ")", ":", "_num_bytes_saved_in_path_data", "+=", "(", "len", "(", "oldPathStr", ")", "-", "len", "(", "newPathStr", ")", ")", "element", ".", "setAttribute", "(", "'d'", ",", "newPathStr", ")" ]

[ "Cleans", "the", "path", "string", "(", "d", "attribute", ")", "of", "the", "element" ]

[ "def", "verify_key", "(", "self", ",", "url", ")", ":", "response", "=", "self", ".", "_request", "(", "'verify-key'", ",", "{", "'blog'", ":", "url", ",", "'key'", ":", "self", ".", "_key", "}", ")", "if", "response", ".", "status", "is", "200", ":", "# Read response (trimmed of whitespace)", "return", "response", ".", "read", "(", ")", ".", "strip", "(", ")", "==", "\"valid\"", "return", "False" ]

[ "For", "verifying", "your", "API", "key", ".", "Provide", "the", "URL", "of", "your", "site", "or", "blog", "you", "will", "be", "checking", "spam", "from", "." ]

[ "def", "update", "(", "self", ",", "members", ")", ":", "if", "isinstance", "(", "members", ",", "RedisSet", ")", ":", "size", "=", "self", ".", "size", "return", "(", "self", ".", "unionstore", "(", "self", ".", "key_prefix", ",", "members", ".", "key_prefix", ")", "-", "size", ")", "if", "self", ".", "serialized", ":", "members", "=", "list", "(", "map", "(", "self", ".", "_dumps", ",", "members", ")", ")", "if", "members", ":", "return", "self", ".", "_client", ".", "sadd", "(", "self", ".", "key_prefix", ",", "*", "members", ")", "return", "0" ]

[ "Adds", "@members", "to", "the", "set", "@members", ":", "a", ":", "class", ":", "RedisSet", "object", "or", "#set" ]

[ "def", "create_mask", "(", "N", ",", "method", "=", "'all'", ",", "nmissing", "=", "0", ")", ":", "weights", "=", "np", ".", "ones", "(", "(", "N", ",", "N", ")", ")", "weights", "[", "range", "(", "N", ")", ",", "range", "(", "N", ")", "]", "=", "0", "if", "method", "==", "'none'", ":", "return", "weights", "# create indices object to choose from", "elif", "method", "==", "'all'", ":", "all_indices", "=", "np", ".", "triu_indices", "(", "N", ",", "1", ")", "elif", "method", "==", "'first'", ":", "all_indices", "=", "[", "np", ".", "zeros", "(", "N", "-", "1", ")", ".", "astype", "(", "np", ".", "int", ")", ",", "np", ".", "arange", "(", "1", ",", "N", ")", ".", "astype", "(", "np", ".", "int", ")", "]", "ntotal", "=", "len", "(", "all_indices", "[", "0", "]", ")", "# randomly choose from indices and set to 0", "choice", "=", "np", ".", "random", ".", "choice", "(", "ntotal", ",", "nmissing", ",", "replace", "=", "False", ")", "chosen", "=", "[", "all_indices", "[", "0", "]", "[", "choice", "]", ",", "all_indices", "[", "1", "]", "[", "choice", "]", "]", "weights", "[", "chosen", "]", "=", "0", "weights", "[", "chosen", "[", "1", "]", ",", "chosen", "[", "0", "]", "]", "=", "0", "return", "weights" ]

[ "Create", "weight", "mask", "according", "to", "method", "." ]

[ "def", "nn", "(", "self", ",", "x", ",", "k", "=", "1", ",", "radius", "=", "np", ".", "inf", ",", "eps", "=", "0.0", ",", "p", "=", "2", ")", ":", "assert", "len", "(", "x", ")", "==", "self", ".", "dim", ",", "'dimension of input {} does not match expected dimension {}.'", ".", "format", "(", "len", "(", "x", ")", ",", "self", ".", "dim", ")", "k_x", "=", "min", "(", "k", ",", "self", ".", "size", ")", "# Because linear models requires x vector to be extended to [1.0]+x", "# to accomodate a constant, we store them that way.", "return", "self", ".", "_nn", "(", "np", ".", "array", "(", "x", ")", ",", "k_x", ",", "radius", "=", "radius", ",", "eps", "=", "eps", ",", "p", "=", "p", ")" ]

[ "Find", "the", "k", "nearest", "neighbors", "of", "x", "in", "the", "observed", "input", "data", ":", "arg", "x", ":", "center", ":", "arg", "k", ":", "the", "number", "of", "nearest", "neighbors", "to", "return", "(", "default", ":", "1", ")", ":", "arg", "eps", ":", "approximate", "nearest", "neighbors", ".", "the", "k", "-", "th", "returned", "value", "is", "guaranteed", "to", "be", "no", "further", "than", "(", "1", "+", "eps", ")", "times", "the", "distance", "to", "the", "real", "k", "-", "th", "nearest", "neighbor", ".", ":", "arg", "p", ":", "Which", "Minkowski", "p", "-", "norm", "to", "use", ".", "(", "default", ":", "2", "euclidean", ")", ":", "arg", "radius", ":", "the", "maximum", "radius", "(", "default", ":", "+", "inf", ")", ":", "return", ":", "distance", "and", "indexes", "of", "found", "nearest", "neighbors", "." ]

[ "def", "create", "(", "policy_backbone", ":", "ModelFactory", ",", "value_backbone", ":", "ModelFactory", ",", "input_block", ":", "typing", ".", "Optional", "[", "ModelFactory", "]", "=", "None", ")", ":", "if", "input_block", "is", "None", ":", "input_block", "=", "IdentityFactory", "(", ")", "return", "DeterministicPolicyModelFactory", "(", "input_block", "=", "input_block", ",", "policy_backbone", "=", "policy_backbone", ",", "value_backbone", "=", "value_backbone", ")" ]

[ "Vel", "factory", "function" ]

[ "def", "build_markdown_body", "(", "self", ",", "text", ")", ":", "key_options", "=", "{", "'dateCreated'", ":", "self", ".", "process_date_created", ",", "'dateUpdated'", ":", "self", ".", "process_date_updated", ",", "'title'", ":", "self", ".", "process_title", ",", "'text'", ":", "self", ".", "process_input", "}", "for", "paragraph", "in", "text", "[", "'paragraphs'", "]", ":", "if", "'user'", "in", "paragraph", ":", "self", ".", "user", "=", "paragraph", "[", "'user'", "]", "for", "key", ",", "handler", "in", "key_options", ".", "items", "(", ")", ":", "if", "key", "in", "paragraph", ":", "handler", "(", "paragraph", "[", "key", "]", ")", "if", "self", ".", "_RESULT_KEY", "in", "paragraph", ":", "self", ".", "process_results", "(", "paragraph", ")" ]

[ "Generate", "the", "body", "for", "the", "Markdown", "file", "." ]

[ "def", "_item_to_metric", "(", "iterator", ",", "log_metric_pb", ")", ":", "# NOTE: LogMetric message type does not have an ``Any`` field", "# so `MessageToDict`` can safely be used.", "resource", "=", "MessageToDict", "(", "log_metric_pb", ")", "return", "Metric", ".", "from_api_repr", "(", "resource", ",", "iterator", ".", "client", ")" ]

[ "Convert", "a", "metric", "protobuf", "to", "the", "native", "object", "." ]

[ "def", "query_entries", "(", "queryset", "=", "None", ",", "year", "=", "None", ",", "month", "=", "None", ",", "day", "=", "None", ",", "category", "=", "None", ",", "category_slug", "=", "None", ",", "tag", "=", "None", ",", "tag_slug", "=", "None", ",", "author", "=", "None", ",", "author_slug", "=", "None", ",", "future", "=", "False", ",", "order", "=", "None", ",", "orderby", "=", "None", ",", "limit", "=", "None", ",", ")", ":", "if", "queryset", "is", "None", ":", "queryset", "=", "get_entry_model", "(", ")", ".", "objects", ".", "all", "(", ")", "if", "appsettings", ".", "FLUENT_BLOGS_FILTER_SITE_ID", ":", "queryset", "=", "queryset", ".", "parent_site", "(", "settings", ".", "SITE_ID", ")", "if", "not", "future", ":", "queryset", "=", "queryset", ".", "published", "(", ")", "if", "year", ":", "queryset", "=", "queryset", ".", "filter", "(", "publication_date__year", "=", "year", ")", "if", "month", ":", "queryset", "=", "queryset", ".", "filter", "(", "publication_date__month", "=", "month", ")", "if", "day", ":", "queryset", "=", "queryset", ".", "filter", "(", "publication_date__day", "=", "day", ")", "# The main category/tag/author filters", "if", "category", ":", "if", "isinstance", "(", "category", ",", "basestring", ")", ":", "queryset", "=", "queryset", ".", "categories", "(", "category", ")", "elif", "isinstance", "(", "category", ",", "(", "int", ",", "long", ")", ")", ":", "queryset", "=", "queryset", ".", "filter", "(", "categories", "=", "category", ")", "else", ":", "raise", "ValueError", "(", "\"Expected slug or ID for the 'category' parameter\"", ")", "if", "category_slug", ":", "queryset", "=", "queryset", ".", "categories", "(", "category", ")", "if", "tag", ":", "if", "isinstance", "(", "tag", ",", "basestring", ")", ":", "queryset", "=", "queryset", ".", "tagged", "(", "tag", ")", "elif", "isinstance", "(", "tag", ",", "(", "int", ",", "long", ")", ")", ":", "queryset", "=", "queryset", ".", "filter", "(", "tags", "=", "tag", ")", "else", ":", "raise", "ValueError", "(", "\"Expected slug or ID for 'tag' parameter.\"", ")", "if", "tag_slug", ":", "queryset", "=", "queryset", ".", "tagged", "(", "tag", ")", "if", "author", ":", "if", "isinstance", "(", "author", ",", "basestring", ")", ":", "queryset", "=", "queryset", ".", "authors", "(", "author", ")", "elif", "isinstance", "(", "author", ",", "(", "int", ",", "long", ")", ")", ":", "queryset", "=", "queryset", ".", "filter", "(", "author", "=", "author", ")", "else", ":", "raise", "ValueError", "(", "\"Expected slug or ID for 'author' parameter.\"", ")", "if", "author_slug", ":", "queryset", "=", "queryset", ".", "authors", "(", "author_slug", ")", "# Ordering", "if", "orderby", ":", "queryset", "=", "queryset", ".", "order_by", "(", "*", "_get_order_by", "(", "order", ",", "orderby", ",", "ENTRY_ORDER_BY_FIELDS", ")", ")", "else", ":", "queryset", "=", "queryset", ".", "order_by", "(", "'-publication_date'", ")", "# Limit", "if", "limit", ":", "queryset", "=", "queryset", "[", ":", "limit", "]", "return", "queryset" ]

[ "Query", "the", "entries", "using", "a", "set", "of", "predefined", "filters", ".", "This", "interface", "is", "mainly", "used", "by", "the", "get_entries", "template", "tag", "." ]

[ "def", "clientCutText", "(", "self", ",", "message", ")", ":", "self", ".", "transport", ".", "write", "(", "pack", "(", "\"!BxxxI\"", ",", "6", ",", "len", "(", "message", ")", ")", "+", "message", ")" ]

[ "The", "client", "has", "new", "ASCII", "text", "in", "its", "cut", "buffer", ".", "(", "aka", "clipboard", ")" ]

[ "def", "show_non_search_results", "(", "log_rec", ",", "code_view", "=", "True", ",", "json_view", "=", "False", ",", "show_message_details", "=", "False", ")", ":", "log_dict", "=", "None", "try", ":", "log_dict", "=", "json", ".", "loads", "(", "log_rec", ")", "except", "Exception", "as", "e", ":", "log_dict", "=", "None", "# end of try/ex", "if", "not", "log_dict", ":", "log", ".", "info", "(", "(", "'{}'", ")", ".", "format", "(", "ppj", "(", "log_rec", ")", ")", ")", "else", ":", "log", ".", "info", "(", "(", "'{}'", ")", ".", "format", "(", "ppj", "(", "log_dict", ")", ")", ")" ]

[ "show_non_search_results" ]

[ "def", "BuildNodes", "(", "self", ",", "nodes", ")", ":", "if", "self", ".", "logstream", "is", "not", "None", ":", "# override stdout / stderr to write in log file", "oldStdout", "=", "sys", ".", "stdout", "sys", ".", "stdout", "=", "self", ".", "logstream", "oldStderr", "=", "sys", ".", "stderr", "sys", ".", "stderr", "=", "self", ".", "logstream", "# the engine assumes the current path is the SConstruct directory ...", "old_fs_dir", "=", "SConfFS", ".", "getcwd", "(", ")", "old_os_dir", "=", "os", ".", "getcwd", "(", ")", "SConfFS", ".", "chdir", "(", "SConfFS", ".", "Top", ",", "change_os_dir", "=", "1", ")", "# Because we take responsibility here for writing out our", "# own .sconsign info (see SConfBuildTask.execute(), above),", "# we override the store_info() method with a null place-holder", "# so we really control how it gets written.", "for", "n", "in", "nodes", ":", "n", ".", "store_info", "=", "0", "if", "not", "hasattr", "(", "n", ",", "'attributes'", ")", ":", "n", ".", "attributes", "=", "SCons", ".", "Node", ".", "Node", ".", "Attrs", "(", ")", "n", ".", "attributes", ".", "keep_targetinfo", "=", "1", "ret", "=", "1", "try", ":", "# ToDo: use user options for calc", "save_max_drift", "=", "SConfFS", ".", "get_max_drift", "(", ")", "SConfFS", ".", "set_max_drift", "(", "0", ")", "tm", "=", "SCons", ".", "Taskmaster", ".", "Taskmaster", "(", "nodes", ",", "SConfBuildTask", ")", "# we don't want to build tests in parallel", "jobs", "=", "SCons", ".", "Job", ".", "Jobs", "(", "1", ",", "tm", ")", "jobs", ".", "run", "(", ")", "for", "n", "in", "nodes", ":", "state", "=", "n", ".", "get_state", "(", ")", "if", "(", "state", "!=", "SCons", ".", "Node", ".", "executed", "and", "state", "!=", "SCons", ".", "Node", ".", "up_to_date", ")", ":", "# the node could not be built. we return 0 in this case", "ret", "=", "0", "finally", ":", "SConfFS", ".", "set_max_drift", "(", "save_max_drift", ")", "os", ".", "chdir", "(", "old_os_dir", ")", "SConfFS", ".", "chdir", "(", "old_fs_dir", ",", "change_os_dir", "=", "0", ")", "if", "self", ".", "logstream", "is", "not", "None", ":", "# restore stdout / stderr", "sys", ".", "stdout", "=", "oldStdout", "sys", ".", "stderr", "=", "oldStderr", "return", "ret" ]

[ "Tries", "to", "build", "the", "given", "nodes", "immediately", ".", "Returns", "1", "on", "success", "0", "on", "error", "." ]

[ "def", "info", "(", "self", ")", ":", "return", "itertools", ".", "chain", "(", "self", ".", "pods", ",", "self", ".", "assumptions", ",", "self", ".", "warnings", ")" ]

[ "The", "pods", "assumptions", "and", "warnings", "of", "this", "result", "." ]

[ "def", "_create_bound", "(", "model", ",", "reaction", ",", "bound_type", ",", "f_replace", ",", "units", "=", "None", ",", "flux_udef", "=", "None", ")", ":", "value", "=", "getattr", "(", "reaction", ",", "bound_type", ")", "if", "value", "==", "config", ".", "lower_bound", ":", "return", "LOWER_BOUND_ID", "elif", "value", "==", "0", ":", "return", "ZERO_BOUND_ID", "elif", "value", "==", "config", ".", "upper_bound", ":", "return", "UPPER_BOUND_ID", "elif", "value", "==", "-", "float", "(", "\"Inf\"", ")", ":", "return", "BOUND_MINUS_INF", "elif", "value", "==", "float", "(", "\"Inf\"", ")", ":", "return", "BOUND_PLUS_INF", "else", ":", "# new parameter", "rid", "=", "reaction", ".", "id", "if", "f_replace", "and", "F_REACTION_REV", "in", "f_replace", ":", "rid", "=", "f_replace", "[", "F_REACTION_REV", "]", "(", "rid", ")", "pid", "=", "rid", "+", "\"_\"", "+", "bound_type", "_create_parameter", "(", "model", ",", "pid", "=", "pid", ",", "value", "=", "value", ",", "sbo", "=", "SBO_FLUX_BOUND", ",", "units", "=", "units", ",", "flux_udef", "=", "flux_udef", ")", "return", "pid" ]

[ "Creates", "bound", "in", "model", "for", "given", "reaction", "." ]

[ "def", "update_iptables", "(", "self", ")", ":", "# Read the iptables", "iptables_cmds", "=", "[", "'iptables-save'", ",", "'-c'", "]", "all_rules", "=", "dsl", ".", "execute", "(", "iptables_cmds", ",", "root_helper", "=", "self", ".", "_root_helper", ",", "log_output", "=", "False", ")", "# For each rule in rule_info update the rule if necessary.", "new_rules", "=", "[", "]", "is_modified", "=", "False", "for", "line", "in", "all_rules", ".", "split", "(", "'\\n'", ")", ":", "new_line", "=", "line", "line_content", "=", "line", ".", "split", "(", ")", "# The spoofing rule which includes mac and ip should have", "# -s cidr/32 option for ip address. Otherwise no rule", "# will be modified.", "if", "'-s'", "in", "line_content", ":", "tmp_rule_info", "=", "list", "(", "self", ".", "rule_info", ")", "for", "rule", "in", "tmp_rule_info", ":", "if", "(", "rule", ".", "mac", "in", "line", ".", "lower", "(", ")", "and", "rule", ".", "chain", ".", "lower", "(", ")", "in", "line", ".", "lower", "(", ")", "and", "not", "self", ".", "_is_ip_in_rule", "(", "rule", ".", "ip", ",", "line_content", ")", ")", ":", "ip_loc", "=", "line_content", ".", "index", "(", "'-s'", ")", "+", "1", "line_content", "[", "ip_loc", "]", "=", "rule", ".", "ip", "+", "'/32'", "new_line", "=", "' '", ".", "join", "(", "line_content", ")", "LOG", ".", "debug", "(", "'Modified %(old_rule)s. '", "'New rule is %(new_rule)s.'", "%", "(", "{", "'old_rule'", ":", "line", ",", "'new_rule'", ":", "new_line", "}", ")", ")", "is_modified", "=", "True", "new_rules", ".", "append", "(", "new_line", ")", "if", "is_modified", "and", "new_rules", ":", "# Updated all the rules. Now commit the new rules.", "iptables_cmds", "=", "[", "'iptables-restore'", ",", "'-c'", "]", "dsl", ".", "execute", "(", "iptables_cmds", ",", "process_input", "=", "'\\n'", ".", "join", "(", "new_rules", ")", ",", "root_helper", "=", "self", ".", "_root_helper", ",", "log_output", "=", "False", ")" ]

[ "Update", "iptables", "based", "on", "information", "in", "the", "rule_info", "." ]

[ "def", "delete_thumbnails", "(", "relative_source_path", ",", "root", "=", "None", ",", "basedir", "=", "None", ",", "subdir", "=", "None", ",", "prefix", "=", "None", ")", ":", "thumbs", "=", "thumbnails_for_file", "(", "relative_source_path", ",", "root", ",", "basedir", ",", "subdir", ",", "prefix", ")", "return", "_delete_using_thumbs_list", "(", "thumbs", ")" ]

[ "Delete", "all", "thumbnails", "for", "a", "source", "image", "." ]

[ "def", "start_blocking", "(", "self", ")", ":", "self", ".", "_cav_started", ".", "clear", "(", ")", "self", ".", "start", "(", ")", "self", ".", "_cav_started", ".", "wait", "(", ")" ]

[ "Start", "the", "advertiser", "in", "the", "background", "but", "wait", "until", "it", "is", "ready" ]

[ "def", "get_date", "(", "date", ")", ":", "if", "type", "(", "date", ")", "is", "str", ":", "return", "datetime", ".", "strptime", "(", "date", ",", "'%Y-%m-%d'", ")", ".", "date", "(", ")", "else", ":", "return", "date" ]

[ "Get", "the", "date", "from", "a", "value", "that", "could", "be", "a", "date", "object", "or", "a", "string", "." ]

[ "def", "_maybe_localize_point", "(", "ts", ",", "is_none", ",", "is_not_none", ",", "freq", ",", "tz", ")", ":", "# Make sure start and end are timezone localized if:", "# 1) freq = a Timedelta-like frequency (Tick)", "# 2) freq = None i.e. generating a linspaced range", "if", "isinstance", "(", "freq", ",", "Tick", ")", "or", "freq", "is", "None", ":", "localize_args", "=", "{", "'tz'", ":", "tz", ",", "'ambiguous'", ":", "False", "}", "else", ":", "localize_args", "=", "{", "'tz'", ":", "None", "}", "if", "is_none", "is", "None", "and", "is_not_none", "is", "not", "None", ":", "ts", "=", "ts", ".", "tz_localize", "(", "*", "*", "localize_args", ")", "return", "ts" ]

[ "Localize", "a", "start", "or", "end", "Timestamp", "to", "the", "timezone", "of", "the", "corresponding", "start", "or", "end", "Timestamp" ]

[ "def", "get_sdb_by_id", "(", "self", ",", "sdb_id", ")", ":", "sdb_resp", "=", "get_with_retry", "(", "self", ".", "cerberus_url", "+", "'/v2/safe-deposit-box/'", "+", "sdb_id", ",", "headers", "=", "self", ".", "HEADERS", ")", "throw_if_bad_response", "(", "sdb_resp", ")", "return", "sdb_resp", ".", "json", "(", ")" ]

[ "Return", "the", "details", "for", "the", "given", "safe", "deposit", "box", "id" ]

[ "def", "resolve", "(", "val", ")", ":", "name", "=", "val", ".", "getName", "(", ")", "if", "name", "==", "\"number\"", ":", "try", ":", "return", "int", "(", "val", ".", "number", ")", "except", "ValueError", ":", "return", "Decimal", "(", "val", ".", "number", ")", "elif", "name", "==", "\"str\"", ":", "return", "unwrap", "(", "val", ".", "str", ")", "elif", "name", "==", "\"null\"", ":", "return", "None", "elif", "name", "==", "\"binary\"", ":", "return", "Binary", "(", "val", ".", "binary", "[", "2", ":", "-", "1", "]", ")", "elif", "name", "==", "\"set\"", ":", "if", "val", ".", "set", "==", "\"()\"", ":", "return", "set", "(", ")", "return", "set", "(", "[", "resolve", "(", "v", ")", "for", "v", "in", "val", ".", "set", "]", ")", "elif", "name", "==", "\"bool\"", ":", "return", "val", ".", "bool", "==", "\"TRUE\"", "elif", "name", "==", "\"list\"", ":", "return", "[", "resolve", "(", "v", ")", "for", "v", "in", "val", ".", "list", "]", "elif", "name", "==", "\"dict\"", ":", "dict_val", "=", "{", "}", "for", "k", ",", "v", "in", "val", ".", "dict", ":", "dict_val", "[", "resolve", "(", "k", ")", "]", "=", "resolve", "(", "v", ")", "return", "dict_val", "elif", "name", "==", "\"ts_function\"", ":", "return", "dt_to_ts", "(", "eval_function", "(", "val", ".", "ts_function", ")", ")", "elif", "name", "==", "\"ts_expression\"", ":", "return", "dt_to_ts", "(", "eval_expression", "(", "val", ")", ")", "else", ":", "raise", "SyntaxError", "(", "\"Unable to resolve value '%s'\"", "%", "val", ")" ]

[ "Convert", "a", "pyparsing", "value", "to", "the", "python", "type" ]

[ "def", "update_xml_element", "(", "self", ")", ":", "super", "(", "Description", ",", "self", ")", ".", "update_xml_element", "(", ")", "if", "hasattr", "(", "self", ",", "'lang'", ")", ":", "self", ".", "xml_element", ".", "set", "(", "'{http://www.w3.org/XML/1998/namespace}lang'", ",", "self", ".", "lang", ")", "if", "hasattr", "(", "self", ",", "'override'", ")", ":", "self", ".", "xml_element", ".", "set", "(", "'override'", ",", "str", "(", "self", ".", "override", ")", ")", "return", "self", ".", "xml_element" ]

[ "Updates", "the", "xml", "element", "contents", "to", "matches", "the", "instance", "contents", "." ]

[ "def", "check_python_classifiers", "(", "package_info", ",", "*", "args", ")", ":", "classifiers", "=", "package_info", ".", "get", "(", "'classifiers'", ")", "reason", "=", "\"Python classifiers missing\"", "result", "=", "False", "if", "len", "(", "[", "c", "for", "c", "in", "classifiers", "if", "c", ".", "startswith", "(", "'Programming Language :: Python ::'", ")", "]", ")", ">", "0", ":", "result", "=", "True", "return", "result", ",", "reason", ",", "HAS_PYTHON_CLASSIFIERS" ]

[ "Does", "the", "package", "have", "Python", "classifiers?", ":", "param", "package_info", ":", "package_info", "dictionary", ":", "return", ":", "Tuple", "(", "is", "the", "condition", "True", "or", "False?", "reason", "if", "it", "is", "False", "else", "None", "score", "to", "be", "applied", ")" ]

[ "def", "load", "(", "self", ",", "prefix", "=", "None", ",", "depth", "=", "None", ")", ":", "prefix", "=", "prefix", "or", "self", ".", "prefix", "prefix", "=", "'/'", "+", "prefix", ".", "strip", "(", "'/'", ")", "+", "'/'", "if", "depth", "is", "None", ":", "depth", "=", "self", ".", "inherit_depth", "if", "not", "self", ".", "configured", ":", "log", ".", "debug", "(", "\"etcd not available\"", ")", "return", "if", "self", ".", "watching", ":", "log", ".", "info", "(", "\"Starting watcher for %r\"", ",", "prefix", ")", "self", ".", "start_watching", "(", ")", "log", ".", "info", "(", "\"Loading from etcd %r\"", ",", "prefix", ")", "try", ":", "result", "=", "self", ".", "client", ".", "get", "(", "prefix", ")", "except", "self", ".", "module", ".", "EtcdKeyNotFound", ":", "result", "=", "None", "if", "not", "result", ":", "log", ".", "info", "(", "\"No configuration found\"", ")", "return", "{", "}", "# Iterate over the returned keys from etcd", "update", "=", "{", "}", "for", "item", "in", "result", ".", "children", ":", "key", "=", "item", ".", "key", "value", "=", "item", ".", "value", "# Try to parse them as JSON strings, just in case it works", "try", ":", "value", "=", "pytool", ".", "json", ".", "from_json", "(", "value", ")", "except", ":", "pass", "# Make the key lower-case if we're not case-sensitive", "if", "not", "self", ".", "case_sensitive", ":", "key", "=", "key", ".", "lower", "(", ")", "# Strip off the prefix that we're using", "if", "key", ".", "startswith", "(", "prefix", ")", ":", "key", "=", "key", "[", "len", "(", "prefix", ")", ":", "]", "# Store the key/value to update the config", "update", "[", "key", "]", "=", "value", "# Access cached settings directly to avoid recursion", "inherited", "=", "Config", "(", ")", ".", "settings", ".", "get", "(", "self", ".", "inherit_key", ",", "update", ".", "get", "(", "self", ".", "inherit_key", ",", "None", ")", ")", "if", "depth", ">", "0", "and", "inherited", ":", "log", ".", "info", "(", "\" ... inheriting ...\"", ")", "inherited", "=", "self", ".", "load", "(", "inherited", ",", "depth", "-", "1", ")", "or", "{", "}", "inherited", ".", "update", "(", "update", ")", "update", "=", "inherited", "return", "update" ]

[ "Return", "a", "dictionary", "of", "settings", "loaded", "from", "etcd", "." ]

[ "def", "encode_task_experimental", "(", "task", ")", ":", "# First, clean the task:", "task", "=", "task", ".", "copy", "(", ")", "if", "'tags'", "in", "task", ":", "task", "[", "'tags'", "]", "=", "','", ".", "join", "(", "task", "[", "'tags'", "]", ")", "for", "k", "in", "task", ":", "task", "[", "k", "]", "=", "encode_task_value", "(", "k", ",", "task", "[", "k", "]", ")", "# Then, format it as a string", "return", "[", "\"%s:\\\"%s\\\"\"", "%", "(", "k", ",", "v", ")", "if", "v", "else", "\"%s:\"", "%", "(", "k", ",", ")", "for", "k", ",", "v", "in", "sorted", "(", "task", ".", "items", "(", ")", ",", "key", "=", "itemgetter", "(", "0", ")", ")", "]" ]

[ "Convert", "a", "dict", "-", "like", "task", "to", "its", "string", "representation", "Used", "for", "adding", "a", "task", "via", "task", "add" ]

[ "def", "_build_idp_config_endpoints", "(", "self", ",", "config", ",", "providers", ")", ":", "# Add an endpoint to each provider", "idp_endpoints", "=", "[", "]", "for", "endp_category", "in", "self", ".", "endpoints", ":", "for", "func", ",", "endpoint", "in", "self", ".", "endpoints", "[", "endp_category", "]", ".", "items", "(", ")", ":", "for", "provider", "in", "providers", ":", "_endpoint", "=", "\"{base}/{provider}/{endpoint}\"", ".", "format", "(", "base", "=", "self", ".", "base_url", ",", "provider", "=", "provider", ",", "endpoint", "=", "endpoint", ")", "idp_endpoints", ".", "append", "(", "(", "_endpoint", ",", "func", ")", ")", "config", "[", "\"service\"", "]", "[", "\"idp\"", "]", "[", "\"endpoints\"", "]", "[", "endp_category", "]", "=", "idp_endpoints", "return", "config" ]

[ "Builds", "the", "final", "frontend", "module", "config" ]

[ "def", "revoke_auth", "(", "self", ",", "load", ")", ":", "load", "=", "self", ".", "__verify_load", "(", "load", ",", "(", "'id'", ",", "'tok'", ")", ")", "if", "not", "self", ".", "opts", ".", "get", "(", "'allow_minion_key_revoke'", ",", "False", ")", ":", "log", ".", "warning", "(", "'Minion %s requested key revoke, but allow_minion_key_revoke '", "'is set to False'", ",", "load", "[", "'id'", "]", ")", "return", "load", "if", "load", "is", "False", ":", "return", "load", "else", ":", "return", "self", ".", "masterapi", ".", "revoke_auth", "(", "load", ")" ]

[ "Allow", "a", "minion", "to", "request", "revocation", "of", "its", "own", "key" ]

[ "def", "create", "(", "self", ",", "product_type", ",", "attribute_set_id", ",", "sku", ",", "data", ")", ":", "return", "int", "(", "self", ".", "call", "(", "'catalog_product.create'", ",", "[", "product_type", ",", "attribute_set_id", ",", "sku", ",", "data", "]", ")", ")" ]

[ "Create", "Product", "and", "return", "ID" ]

[ "def", "create_entity", "(", "self", ",", "name", ",", "gl_structure", ",", "description", "=", "None", ")", ":", "new_entity", "=", "Entity", "(", "name", ",", "gl_structure", ",", "description", "=", "description", ")", "self", ".", "entities", ".", "append", "(", "new_entity", ")", "return", "new_entity" ]

[ "Create", "an", "entity", "and", "add", "it", "to", "the", "model", "." ]

[ "def", "read_projection_from_fits", "(", "fitsfile", ",", "extname", "=", "None", ")", ":", "f", "=", "fits", ".", "open", "(", "fitsfile", ")", "nhdu", "=", "len", "(", "f", ")", "# Try and get the energy bounds", "try", ":", "ebins", "=", "find_and_read_ebins", "(", "f", ")", "except", ":", "ebins", "=", "None", "if", "extname", "is", "None", ":", "# If there is an image in the Primary HDU we can return a WCS-based", "# projection", "if", "f", "[", "0", "]", ".", "header", "[", "'NAXIS'", "]", "!=", "0", ":", "proj", "=", "WCS", "(", "f", "[", "0", "]", ".", "header", ")", "return", "proj", ",", "f", ",", "f", "[", "0", "]", "else", ":", "if", "f", "[", "extname", "]", ".", "header", "[", "'XTENSION'", "]", "==", "'IMAGE'", ":", "proj", "=", "WCS", "(", "f", "[", "extname", "]", ".", "header", ")", "return", "proj", ",", "f", ",", "f", "[", "extname", "]", "elif", "extname", "in", "[", "'SKYMAP'", ",", "'SKYMAP2'", "]", ":", "proj", "=", "HPX", ".", "create_from_hdu", "(", "f", "[", "extname", "]", ",", "ebins", ")", "return", "proj", ",", "f", ",", "f", "[", "extname", "]", "elif", "f", "[", "extname", "]", ".", "header", "[", "'XTENSION'", "]", "==", "'BINTABLE'", ":", "try", ":", "if", "f", "[", "extname", "]", ".", "header", "[", "'PIXTYPE'", "]", "==", "'HEALPIX'", ":", "proj", "=", "HPX", ".", "create_from_hdu", "(", "f", "[", "extname", "]", ",", "ebins", ")", "return", "proj", ",", "f", ",", "f", "[", "extname", "]", "except", ":", "pass", "return", "None", ",", "f", ",", "None", "# Loop on HDU and look for either an image or a table with HEALPix data", "for", "i", "in", "range", "(", "1", ",", "nhdu", ")", ":", "# if there is an image we can return a WCS-based projection", "if", "f", "[", "i", "]", ".", "header", "[", "'XTENSION'", "]", "==", "'IMAGE'", ":", "proj", "=", "WCS", "(", "f", "[", "i", "]", ".", "header", ")", "return", "proj", ",", "f", ",", "f", "[", "i", "]", "elif", "f", "[", "i", "]", ".", "header", "[", "'XTENSION'", "]", "==", "'BINTABLE'", ":", "if", "f", "[", "i", "]", ".", "name", "in", "[", "'SKYMAP'", ",", "'SKYMAP2'", "]", ":", "proj", "=", "HPX", ".", "create_from_hdu", "(", "f", "[", "i", "]", ",", "ebins", ")", "return", "proj", ",", "f", ",", "f", "[", "i", "]", "try", ":", "if", "f", "[", "i", "]", ".", "header", "[", "'PIXTYPE'", "]", "==", "'HEALPIX'", ":", "proj", "=", "HPX", ".", "create_from_hdu", "(", "f", "[", "i", "]", ",", "ebins", ")", "return", "proj", ",", "f", ",", "f", "[", "i", "]", "except", ":", "pass", "return", "None", ",", "f", ",", "None" ]

[ "Load", "a", "WCS", "or", "HPX", "projection", "." ]

[ "def", "_blocked", "(", "self", ",", "args", ")", ":", "reason", "=", "args", ".", "read_shortstr", "(", ")", "if", "self", ".", "on_blocked", ":", "return", "self", ".", "on_blocked", "(", "reason", ")" ]

[ "RabbitMQ", "Extension", "." ]

[ "def", "decode", "(", "self", ",", "envelope", ",", "session", ",", "target", "=", "None", ",", "modification_code", "=", "None", ",", "*", "*", "kwargs", ")", ":", "self", ".", "__args_check", "(", "envelope", ",", "target", ",", "modification_code", ")", "message", "=", "envelope", ".", "message", "(", ")", "if", "len", "(", "message", ")", "<", "len", "(", "modification_code", ")", ":", "raise", "ValueError", "(", "'Invalid message length'", ")", "if", "isinstance", "(", "envelope", ",", "WMessengerTextEnvelope", ")", ":", "target_envelope_cls", "=", "WMessengerTextEnvelope", "else", ":", "# isinstance(envelope, WMessengerBytesEnvelope)", "target_envelope_cls", "=", "WMessengerBytesEnvelope", "if", "target", "==", "WMessengerFixedModificationLayer", ".", "Target", ".", "head", ":", "if", "message", "[", ":", "len", "(", "modification_code", ")", "]", "!=", "modification_code", ":", "raise", "ValueError", "(", "'Invalid header in message'", ")", "return", "target_envelope_cls", "(", "message", "[", "len", "(", "modification_code", ")", ":", "]", ",", "meta", "=", "envelope", ")", "else", ":", "# target == WMessengerFixedModificationLayer.Target.tail", "if", "message", "[", "-", "len", "(", "modification_code", ")", ":", "]", "!=", "modification_code", ":", "raise", "ValueError", "(", "'Invalid tail in message'", ")", "return", "target_envelope_cls", "(", "message", "[", ":", "-", "len", "(", "modification_code", ")", "]", ",", "meta", "=", "envelope", ")" ]

[ "Methods", "checks", "envelope", "for", "modification_code", "existence", "and", "removes", "it", "." ]

[ "def", "to_selector", "(", "self", ")", ":", "for", "i", "in", "self", ".", "SELECTORS", ":", "if", "hasattr", "(", "self", ",", "i", ")", ":", "val", "=", "getattr", "(", "self", ",", "i", ")", "selector", "=", "i", "break", "return", "{", "selector", ":", "val", "}" ]

[ "For", "some", "reason", "the", "selector", "for", "<identity", ">", "is" ]

[ "def", "print_classification", "(", "self", ",", "cls", ",", "inst", ",", "index", ")", ":", "javabridge", ".", "call", "(", "self", ".", "jobject", ",", "\"printClassification\"", ",", "\"(Lweka/classifiers/Classifier;Lweka/core/Instance;I)V\"", ",", "cls", ".", "jobject", ",", "inst", ".", "jobject", ",", "index", ")" ]

[ "Prints", "the", "classification", "to", "the", "buffer", "." ]

[ "def", "from_json", "(", "self", ",", "data", ")", ":", "try", ":", "d", "=", "json", ".", "loads", "(", "data", ")", "except", "ValueError", ":", "raise", "InvalidMessageException", "(", ")", "self", ".", "from_dict", "(", "d", ")" ]

[ "Initialise", "an", "API", "message", "from", "a", "JSON", "representation", "." ]

[ "def", "save_config", "(", "self", ",", "fname", ",", "output_dir", ",", "cp", "=", "None", ")", ":", "cp", "=", "self", ".", "cp", "if", "cp", "is", "None", "else", "cp", "ini_file_path", "=", "os", ".", "path", ".", "join", "(", "output_dir", ",", "fname", ")", "with", "open", "(", "ini_file_path", ",", "\"wb\"", ")", "as", "fp", ":", "cp", ".", "write", "(", "fp", ")", "ini_file", "=", "FileList", "(", "[", "File", "(", "self", ".", "ifos", ",", "\"\"", ",", "self", ".", "analysis_time", ",", "file_url", "=", "\"file://\"", "+", "ini_file_path", ")", "]", ")", "return", "ini_file" ]

[ "Writes", "configuration", "file", "to", "disk", "and", "returns", "a", "pycbc", ".", "workflow", ".", "File", "instance", "for", "the", "configuration", "file", "." ]

[ "def", "extract_table_names", "(", "query", ")", ":", "# a good old fashioned regex. turns out this worked better than actually parsing the code", "tables_blocks", "=", "re", ".", "findall", "(", "r'(?:FROM|JOIN)\\s+(\\w+(?:\\s*,\\s*\\w+)*)'", ",", "query", ",", "re", ".", "IGNORECASE", ")", "tables", "=", "[", "tbl", "for", "block", "in", "tables_blocks", "for", "tbl", "in", "re", ".", "findall", "(", "r'\\w+'", ",", "block", ")", "]", "return", "set", "(", "tables", ")" ]

[ "Extract", "table", "names", "from", "an", "SQL", "query", "." ]

[ "def", "remove_access_control_lists", "(", "self", ",", "security_namespace_id", ",", "tokens", "=", "None", ",", "recurse", "=", "None", ")", ":", "route_values", "=", "{", "}", "if", "security_namespace_id", "is", "not", "None", ":", "route_values", "[", "'securityNamespaceId'", "]", "=", "self", ".", "_serialize", ".", "url", "(", "'security_namespace_id'", ",", "security_namespace_id", ",", "'str'", ")", "query_parameters", "=", "{", "}", "if", "tokens", "is", "not", "None", ":", "query_parameters", "[", "'tokens'", "]", "=", "self", ".", "_serialize", ".", "query", "(", "'tokens'", ",", "tokens", ",", "'str'", ")", "if", "recurse", "is", "not", "None", ":", "query_parameters", "[", "'recurse'", "]", "=", "self", ".", "_serialize", ".", "query", "(", "'recurse'", ",", "recurse", ",", "'bool'", ")", "response", "=", "self", ".", "_send", "(", "http_method", "=", "'DELETE'", ",", "location_id", "=", "'18a2ad18-7571-46ae-bec7-0c7da1495885'", ",", "version", "=", "'5.0'", ",", "route_values", "=", "route_values", ",", "query_parameters", "=", "query_parameters", ")", "return", "self", ".", "_deserialize", "(", "'bool'", ",", "response", ")" ]

[ "RemoveAccessControlLists", ".", "Remove", "access", "control", "lists", "under", "the", "specfied", "security", "namespace", ".", ":", "param", "str", "security_namespace_id", ":", "Security", "namespace", "identifier", ".", ":", "param", "str", "tokens", ":", "One", "or", "more", "comma", "-", "separated", "security", "tokens", ":", "param", "bool", "recurse", ":", "If", "true", "and", "this", "is", "a", "hierarchical", "namespace", "also", "remove", "child", "ACLs", "of", "the", "specified", "tokens", ".", ":", "rtype", ":", "bool" ]

[ "def", "p_return", "(", "p", ")", ":", "if", "not", "FUNCTION_LEVEL", ":", "# At less one level, otherwise, this return is from a GOSUB", "p", "[", "0", "]", "=", "make_sentence", "(", "'RETURN'", ")", "return", "if", "FUNCTION_LEVEL", "[", "-", "1", "]", ".", "kind", "!=", "KIND", ".", "sub", ":", "syntax_error", "(", "p", ".", "lineno", "(", "1", ")", ",", "'Syntax Error: Functions must RETURN a value, or use EXIT FUNCTION instead.'", ")", "p", "[", "0", "]", "=", "None", "return", "p", "[", "0", "]", "=", "make_sentence", "(", "'RETURN'", ",", "FUNCTION_LEVEL", "[", "-", "1", "]", ")" ]

[ "statement", ":", "RETURN" ]

[ "def", "backup_db", "(", "callback", ",", "bool_func", ",", "output_fname", ",", "*", "args", ",", "*", "*", "kwargs", ")", ":", "from", "datetime", "import", "datetime", "try", ":", "verbose", "=", "kwargs", "[", "'verbose'", "]", "except", "KeyError", ":", "verbose", "=", "False", "try", ":", "retries", "=", "kwargs", "[", "'retries'", "]", "except", "KeyError", ":", "retries", "=", "-", "1", "try", ":", "force_download_latest", "=", "bool", "(", "kwargs", "[", "'force_download_latest'", "]", ")", "except", "KeyError", ":", "force_download_latest", "=", "False", "if", "verbose", ":", "log", "=", "open", "(", "'/tmp/log_mambu_backup'", ",", "'a'", ")", "log", ".", "write", "(", "datetime", ".", "now", "(", ")", ".", "strftime", "(", "'%Y-%m-%d %H:%M:%S'", ")", "+", "\" - Mambu DB Backup\\n\"", ")", "log", ".", "flush", "(", ")", "user", "=", "kwargs", ".", "pop", "(", "'user'", ",", "apiuser", ")", "pwd", "=", "kwargs", ".", "pop", "(", "'pwd'", ",", "apipwd", ")", "data", "=", "{", "'callback'", ":", "callback", "}", "try", ":", "posturl", "=", "iriToUri", "(", "getmambuurl", "(", "*", "args", ",", "*", "*", "kwargs", ")", "+", "\"database/backup\"", ")", "if", "verbose", ":", "log", ".", "write", "(", "\"open url: \"", "+", "posturl", "+", "\"\\n\"", ")", "log", ".", "flush", "(", ")", "resp", "=", "requests", ".", "post", "(", "posturl", ",", "data", "=", "data", ",", "headers", "=", "{", "'content-type'", ":", "'application/json'", "}", ",", "auth", "=", "(", "apiuser", ",", "apipwd", ")", ")", "except", "Exception", "as", "ex", ":", "mess", "=", "\"Error requesting backup: %s\"", "%", "repr", "(", "ex", ")", "if", "verbose", ":", "log", ".", "write", "(", "mess", "+", "\"\\n\"", ")", "log", ".", "close", "(", ")", "raise", "MambuError", "(", "mess", ")", "if", "resp", ".", "status_code", "!=", "200", ":", "mess", "=", "\"Error posting request for backup: %s\"", "%", "resp", ".", "content", "if", "verbose", ":", "log", ".", "write", "(", "mess", "+", "\"\\n\"", ")", "log", ".", "close", "(", ")", "raise", "MambuCommError", "(", "mess", ")", "data", "[", "'latest'", "]", "=", "True", "while", "retries", "and", "not", "bool_func", "(", ")", ":", "if", "verbose", ":", "log", ".", "write", "(", "\"waiting...\\n\"", ")", "log", ".", "flush", "(", ")", "sleep", "(", "10", ")", "retries", "-=", "1", "if", "retries", "<", "0", ":", "retries", "=", "-", "1", "if", "not", "retries", ":", "mess", "=", "\"Tired of waiting, giving up...\"", "if", "verbose", ":", "log", ".", "write", "(", "mess", "+", "\"\\n\"", ")", "log", ".", "flush", "(", ")", "if", "not", "force_download_latest", ":", "if", "verbose", ":", "log", ".", "close", "(", ")", "raise", "MambuError", "(", "mess", ")", "else", ":", "data", "[", "'latest'", "]", "=", "False", "sleep", "(", "30", ")", "geturl", "=", "iriToUri", "(", "getmambuurl", "(", "*", "args", ",", "*", "*", "kwargs", ")", "+", "\"database/backup/LATEST\"", ")", "if", "verbose", ":", "log", ".", "write", "(", "\"open url: \"", "+", "geturl", "+", "\"\\n\"", ")", "log", ".", "flush", "(", ")", "resp", "=", "requests", ".", "get", "(", "geturl", ",", "auth", "=", "(", "apiuser", ",", "apipwd", ")", ")", "if", "resp", ".", "status_code", "!=", "200", ":", "mess", "=", "\"Error getting database backup: %s\"", "%", "resp", ".", "content", "if", "verbose", ":", "log", ".", "write", "(", "mess", "+", "\"\\n\"", ")", "log", ".", "close", "(", ")", "raise", "MambuCommError", "(", "mess", ")", "if", "verbose", ":", "log", ".", "write", "(", "\"saving...\\n\"", ")", "log", ".", "flush", "(", ")", "with", "open", "(", "output_fname", ",", "\"w\"", ")", "as", "fw", ":", "fw", ".", "write", "(", "resp", ".", "content", ")", "if", "verbose", ":", "log", ".", "write", "(", "\"DONE!\\n\"", ")", "log", ".", "close", "(", ")", "return", "data" ]

[ "Backup", "Mambu", "Database", "via", "REST", "API", "." ]

[ "def", "get_index_by_alias", "(", "self", ",", "alias", ")", ":", "try", ":", "info", "=", "self", ".", "es", ".", "indices", ".", "get_alias", "(", "name", "=", "alias", ")", "return", "next", "(", "iter", "(", "info", ".", "keys", "(", ")", ")", ")", "except", "elasticsearch", ".", "exceptions", ".", "NotFoundError", ":", "return", "alias" ]

[ "Get", "index", "name", "for", "given", "alias", "." ]

[ "def", "_normalize_select_no_context", "(", "select", ",", "schema", "=", "None", ")", ":", "if", "not", "_Column", ":", "_late_import", "(", ")", "if", "is_text", "(", "select", ")", ":", "select", "=", "Data", "(", "value", "=", "select", ")", "else", ":", "select", "=", "wrap", "(", "select", ")", "output", "=", "select", ".", "copy", "(", ")", "if", "not", "select", ".", "value", ":", "output", ".", "name", "=", "coalesce", "(", "select", ".", "name", ",", "select", ".", "aggregate", ")", "if", "output", ".", "name", ":", "output", ".", "value", "=", "jx_expression", "(", "\".\"", ",", "schema", "=", "schema", ")", "else", ":", "return", "Null", "elif", "is_text", "(", "select", ".", "value", ")", ":", "if", "select", ".", "value", ".", "endswith", "(", "\".*\"", ")", ":", "name", "=", "select", ".", "value", "[", ":", "-", "2", "]", ".", "lstrip", "(", "\".\"", ")", "output", ".", "name", "=", "coalesce", "(", "select", ".", "name", ",", "name", ")", "output", ".", "value", "=", "LeavesOp", "(", "Variable", "(", "name", ")", ",", "prefix", "=", "coalesce", "(", "select", ".", "prefix", ",", "name", ")", ")", "else", ":", "if", "select", ".", "value", "==", "\".\"", ":", "output", ".", "name", "=", "coalesce", "(", "select", ".", "name", ",", "select", ".", "aggregate", ",", "\".\"", ")", "output", ".", "value", "=", "jx_expression", "(", "select", ".", "value", ",", "schema", "=", "schema", ")", "elif", "select", ".", "value", "==", "\"*\"", ":", "output", ".", "name", "=", "coalesce", "(", "select", ".", "name", ",", "select", ".", "aggregate", ",", "\".\"", ")", "output", ".", "value", "=", "LeavesOp", "(", "Variable", "(", "\".\"", ")", ")", "else", ":", "output", ".", "name", "=", "coalesce", "(", "select", ".", "name", ",", "select", ".", "value", ".", "lstrip", "(", "\".\"", ")", ",", "select", ".", "aggregate", ")", "output", ".", "value", "=", "jx_expression", "(", "select", ".", "value", ",", "schema", "=", "schema", ")", "elif", "is_number", "(", "output", ".", "value", ")", ":", "if", "not", "output", ".", "name", ":", "output", ".", "name", "=", "text_type", "(", "output", ".", "value", ")", "output", ".", "value", "=", "jx_expression", "(", "select", ".", "value", ",", "schema", "=", "schema", ")", "else", ":", "output", ".", "value", "=", "jx_expression", "(", "select", ".", "value", ",", "schema", "=", "schema", ")", "if", "not", "output", ".", "name", ":", "Log", ".", "error", "(", "\"expecting select to have a name: {{select}}\"", ",", "select", "=", "select", ")", "if", "output", ".", "name", ".", "endswith", "(", "\".*\"", ")", ":", "Log", ".", "error", "(", "\"{{name|quote}} is invalid select\"", ",", "name", "=", "output", ".", "name", ")", "output", ".", "aggregate", "=", "coalesce", "(", "canonical_aggregates", "[", "select", ".", "aggregate", "]", ".", "name", ",", "select", ".", "aggregate", ",", "\"none\"", ")", "output", ".", "default", "=", "coalesce", "(", "select", ".", "default", ",", "canonical_aggregates", "[", "output", ".", "aggregate", "]", ".", "default", ")", "return", "output" ]

[ "SAME", "NORMALIZE", "BUT", "NO", "SOURCE", "OF", "COLUMNS" ]

[ "def", "childIds", "(", "self", ")", ":", "if", "self", ".", "depth", ">=", "len", "(", "self", ".", "citation", ".", "root", ")", ":", "return", "[", "]", "elif", "self", ".", "_children", "is", "not", "None", ":", "return", "self", ".", "_children", "else", ":", "self", ".", "_children", "=", "self", ".", "getReffs", "(", ")", "return", "self", ".", "_children" ]

[ "Children", "of", "the", "passage" ]

[ "def", "setNetworkKey", "(", "self", ",", "key", ")", ":", "masterKey", "=", "''", "print", "'%s call setNetworkKey'", "%", "self", ".", "port", "try", ":", "if", "not", "isinstance", "(", "key", ",", "str", ")", ":", "masterKey", "=", "self", ".", "__convertLongToString", "(", "key", ")", "# prpend '0' at the beginning", "if", "len", "(", "masterKey", ")", "<", "32", ":", "masterKey", "=", "masterKey", ".", "zfill", "(", "32", ")", "cmd", "=", "WPANCTL_CMD", "+", "'setprop Network:Key %s'", "%", "masterKey", "datasetCmd", "=", "WPANCTL_CMD", "+", "'setprop Dataset:MasterKey %s'", "%", "masterKey", "else", ":", "masterKey", "=", "key", "cmd", "=", "WPANCTL_CMD", "+", "'setprop Network:Key %s'", "%", "masterKey", "datasetCmd", "=", "WPANCTL_CMD", "+", "'setprop Dataset:MasterKey %s'", "%", "masterKey", "self", ".", "networkKey", "=", "masterKey", "self", ".", "hasActiveDatasetToCommit", "=", "True", "return", "self", ".", "__sendCommand", "(", "cmd", ")", "[", "0", "]", "!=", "'Fail'", "and", "self", ".", "__sendCommand", "(", "datasetCmd", ")", "[", "0", "]", "!=", "'Fail'", "except", "Exception", ",", "e", ":", "ModuleHelper", ".", "WriteIntoDebugLogger", "(", "'setNetworkkey() Error: '", "+", "str", "(", "e", ")", ")" ]

[ "set", "Thread", "Network", "master", "key" ]

[ "def", "run", "(", "cls", ",", "version", "=", "None", ")", ":", "try", ":", "dumper", "=", "certdump", "(", ")", "versions", "=", "dumper", ".", "nssversion_via_marionette", "(", ")", "except", "Exception", "as", "e", ":", "# TODO: too broad exception", "cls", ".", "log_status", "(", "'FAIL'", ",", "'Failed to gather information from the device via Marionette: %s'", "%", "e", ")", "return", "False", "if", "version", "is", "None", ":", "cls", ".", "log_status", "(", "'FAIL'", ",", "'NSS version check requires a B2G version.\\nReported component versions:\\n%s'", "%", "(", "'\\n'", ".", "join", "(", "[", "\"%s: %s\"", "%", "(", "k", ",", "versions", "[", "k", "]", ")", "for", "k", "in", "versions", "]", ")", ")", ")", "return", "False", "reported_version", "=", "versions", "[", "'NSS_Version'", "]", "if", "version", "not", "in", "nssversion", ".", "b2g_version_to_hginfo", ":", "cls", ".", "log_status", "(", "'FAIL'", ",", "'No version comparison data for B2G %s.\\nReported NSS component versions:\\n%s'", "%", "(", "version", ",", "'\\n'", ".", "join", "(", "[", "\"%s: %s\"", "%", "(", "k", ",", "versions", "[", "k", "]", ")", "for", "k", "in", "versions", "]", ")", ")", ")", "return", "False", "expected_version", "=", "nssversion", ".", "b2g_version_to_hginfo", "[", "version", "]", "[", "'release_nss_version'", "]", "# Fail if reported version is a downgrade", "if", "nssversion", ".", "first_older_than_second", "(", "reported_version", ",", "expected_version", ")", ":", "cls", ".", "log_status", "(", "'FAIL'", ",", "'NSS downgrade detected. Expecting at least version %s.\\n'", "'Reported versions:\\n%s'", "%", "(", "expected_version", ",", "'\\n'", ".", "join", "(", "[", "\"%s: %s\"", "%", "(", "k", ",", "versions", "[", "k", "]", ")", "for", "k", "in", "versions", "]", ")", ")", ")", "return", "False", "# Pass if NSS version was upgraded.", "if", "nssversion", ".", "first_older_than_second", "(", "expected_version", ",", "reported_version", ")", ":", "cls", ".", "log_status", "(", "'PASS'", ",", "'NSS more recent than release version %s. Reported component versions:\\n%s'", "%", "(", "expected_version", ",", "'\\n'", ".", "join", "(", "[", "\"%s: %s\"", "%", "(", "k", ",", "versions", "[", "k", "]", ")", "for", "k", "in", "versions", "]", ")", ")", ")", "return", "True", "# Else device has reported the expected version.", "cls", ".", "log_status", "(", "'PASS'", ",", "'NSS version reported as expected. Reported component versions:\\n%s'", "%", "(", "'\\n'", ".", "join", "(", "[", "\"%s: %s\"", "%", "(", "k", ",", "versions", "[", "k", "]", ")", "for", "k", "in", "versions", "]", ")", ")", ")", "return", "True" ]

[ "Test", "runner", "method", ";", "is", "called", "by", "parent", "class", "defined", "in", "suite", ".", "py", ".", ":", "param", "version", ":", "B2G", "version", "string", "to", "test", "against", ":", "return", ":", "bool", "PASS", "/", "FAIL", "status" ]

[ "def", "state", "(", "self", ",", "metric", "=", "None", ",", "index", "=", "None", ",", "params", "=", "None", ")", ":", "if", "index", "and", "not", "metric", ":", "metric", "=", "'_all'", "return", "self", ".", "transport", ".", "perform_request", "(", "'GET'", ",", "_make_path", "(", "'_cluster'", ",", "'state'", ",", "metric", ",", "index", ")", ",", "params", "=", "params", ")" ]

[ "Get", "a", "comprehensive", "state", "information", "of", "the", "whole", "cluster", ".", "<http", ":", "//", "www", ".", "elastic", ".", "co", "/", "guide", "/", "en", "/", "elasticsearch", "/", "reference", "/", "current", "/", "cluster", "-", "state", ".", "html", ">", "_" ]

[ "def", "numeric", "(", "self", ",", "mtx", ")", ":", "self", ".", "free_numeric", "(", ")", "if", "self", ".", "_symbolic", "is", "None", ":", "self", ".", "symbolic", "(", "mtx", ")", "indx", "=", "self", ".", "_getIndx", "(", "mtx", ")", "failCount", "=", "0", "while", "1", ":", "if", "self", ".", "isReal", ":", "status", ",", "self", ".", "_numeric", "=", "self", ".", "funs", ".", "numeric", "(", "mtx", ".", "indptr", ",", "indx", ",", "mtx", ".", "data", ",", "self", ".", "_symbolic", ",", "self", ".", "control", ",", "self", ".", "info", ")", "else", ":", "real", ",", "imag", "=", "mtx", ".", "data", ".", "real", ".", "copy", "(", ")", ",", "mtx", ".", "data", ".", "imag", ".", "copy", "(", ")", "status", ",", "self", ".", "_numeric", "=", "self", ".", "funs", ".", "numeric", "(", "mtx", ".", "indptr", ",", "indx", ",", "real", ",", "imag", ",", "self", ".", "_symbolic", ",", "self", ".", "control", ",", "self", ".", "info", ")", "if", "status", "!=", "UMFPACK_OK", ":", "if", "status", "==", "UMFPACK_WARNING_singular_matrix", ":", "warnings", ".", "warn", "(", "'Singular matrix'", ",", "UmfpackWarning", ")", "break", "elif", "status", "in", "(", "UMFPACK_ERROR_different_pattern", ",", "UMFPACK_ERROR_invalid_Symbolic_object", ")", ":", "# Try again.", "warnings", ".", "warn", "(", "'Recomputing symbolic'", ",", "UmfpackWarning", ")", "self", ".", "symbolic", "(", "mtx", ")", "failCount", "+=", "1", "else", ":", "failCount", "+=", "100", "else", ":", "break", "if", "failCount", ">=", "2", ":", "raise", "RuntimeError", "(", "'%s failed with %s'", "%", "(", "self", ".", "funs", ".", "numeric", ",", "umfStatus", "[", "status", "]", ")", ")" ]

[ "Perform", "numeric", "object", "(", "LU", "decomposition", ")", "computation", "using", "the", "symbolic", "decomposition", ".", "The", "symbolic", "decomposition", "is", "(", "re", ")", "computed", "if", "necessary", "." ]

[ "def", "_get_flat_db_sources", "(", "self", ",", "model", ")", ":", "sources", "=", "[", "]", "for", "source", "in", "self", ".", "sources", ":", "for", "sub_source", "in", "self", ".", "expand_source", "(", "source", ")", ":", "target_field", "=", "self", ".", "resolve_source", "(", "model", ",", "sub_source", ")", "if", "target_field", ":", "sources", ".", "append", "(", "sub_source", ")", "return", "sources" ]

[ "Return", "a", "flattened", "representation", "of", "the", "individual", "sources", "lists", "." ]

[ "def", "_check_peptide_inputs", "(", "self", ",", "peptides", ")", ":", "require_iterable_of", "(", "peptides", ",", "string_types", ")", "check_X", "=", "not", "self", ".", "allow_X_in_peptides", "check_lower", "=", "not", "self", ".", "allow_lowercase_in_peptides", "check_min_length", "=", "self", ".", "min_peptide_length", "is", "not", "None", "min_length", "=", "self", ".", "min_peptide_length", "check_max_length", "=", "self", ".", "max_peptide_length", "is", "not", "None", "max_length", "=", "self", ".", "max_peptide_length", "for", "p", "in", "peptides", ":", "if", "not", "p", ".", "isalpha", "(", ")", ":", "raise", "ValueError", "(", "\"Invalid characters in peptide '%s'\"", "%", "p", ")", "elif", "check_X", "and", "\"X\"", "in", "p", ":", "raise", "ValueError", "(", "\"Invalid character 'X' in peptide '%s'\"", "%", "p", ")", "elif", "check_lower", "and", "not", "p", ".", "isupper", "(", ")", ":", "raise", "ValueError", "(", "\"Invalid lowercase letters in peptide '%s'\"", "%", "p", ")", "elif", "check_min_length", "and", "len", "(", "p", ")", "<", "min_length", ":", "raise", "ValueError", "(", "\"Peptide '%s' too short (%d chars), must be at least %d\"", "%", "(", "p", ",", "len", "(", "p", ")", ",", "min_length", ")", ")", "elif", "check_max_length", "and", "len", "(", "p", ")", ">", "max_length", ":", "raise", "ValueError", "(", "\"Peptide '%s' too long (%d chars), must be at least %d\"", "%", "(", "p", ",", "len", "(", "p", ")", ",", "max_length", ")", ")" ]

[ "Check", "peptide", "sequences", "to", "make", "sure", "they", "are", "valid", "for", "this", "predictor", "." ]

[ "def", "save_url_as", "(", "url", ",", "save_as", ")", ":", "remote", "=", "requests", ".", "get", "(", "url", ",", "verify", "=", "False", ")", "if", "not", "remote", ".", "status_code", "==", "Constants", ".", "PULP_GET_OK", ":", "raise", "JuicerPulpError", "(", "\"A %s error occurred trying to get %s\"", "%", "(", "remote", ".", "status_code", ",", "url", ")", ")", "with", "open", "(", "save_as", ",", "'wb'", ")", "as", "data", ":", "data", ".", "write", "(", "remote", ".", "content", ")" ]

[ "Download", "the", "file", "url", "and", "save", "it", "to", "the", "local", "disk", "as", "save_as", "." ]

[ "def", "op_decanonicalize", "(", "op_name", ",", "canonical_op", ")", ":", "global", "DECANONICALIZE_METHODS", "if", "op_name", "not", "in", "DECANONICALIZE_METHODS", ":", "# no decanonicalization needed", "return", "canonical_op", "else", ":", "return", "DECANONICALIZE_METHODS", "[", "op_name", "]", "(", "canonical_op", ")" ]

[ "Get", "the", "current", "representation", "of", "a", "parsed", "operation", "s", "data", "given", "the", "canonical", "representation", "Meant", "for", "backwards", "-", "compatibility" ]

[ "def", "imread", "(", "path", ",", "grayscale", "=", "False", ",", "size", "=", "None", ",", "interpolate", "=", "\"bilinear\"", ",", "channel_first", "=", "False", ",", "as_uint16", "=", "False", ",", "num_channels", "=", "-", "1", ")", ":", "_imread_before", "(", "grayscale", ",", "num_channels", ")", "f", "=", "path", "if", "hasattr", "(", "path", ",", "\"read\"", ")", "else", "open", "(", "path", ",", "\"rb\"", ")", "r", "=", "png", ".", "Reader", "(", "file", "=", "f", ")", "width", ",", "height", ",", "pixels", ",", "metadata", "=", "r", ".", "asDirect", "(", ")", "bit_depth", "=", "metadata", ".", "get", "(", "\"bitdepth\"", ")", "if", "bit_depth", "not", "in", "[", "8", ",", "16", "]", ":", "raise", "ValueError", "(", "\"The bit-depth of the image you want to read is unsupported ({}bit).\"", "\"Currently, pypng backend`s imread supports only [8, 16] bit-depth.\"", "\"the path for this image is {}\"", ".", "format", "(", "bit_depth", ",", "path", ")", ")", "img", "=", "read_result_to_ndarray", "(", "pixels", ",", "width", ",", "height", ",", "metadata", ",", "grayscale", ",", "as_uint16", ",", "num_channels", ")", "return", "_imread_after", "(", "img", ",", "size", ",", "interpolate", ",", "channel_first", ",", "imresize", ")" ]

[ "Read", "image", "by", "pypng", "module", "." ]

[ "def", "_validate_config", "(", "self", ")", ":", "# exit if no backend specified", "if", "not", "self", ".", "backend", ":", "return", "# exit if no required config keys", "if", "len", "(", "self", ".", "REQUIRED_CONFIG_KEYS", ")", "<", "1", ":", "return", "self", ".", "config", "=", "self", ".", "config", "or", "{", "}", "# default to empty dict of no config", "required_keys_set", "=", "set", "(", "self", ".", "REQUIRED_CONFIG_KEYS", ")", "config_keys_set", "=", "set", "(", "self", ".", "config", ".", "keys", "(", ")", ")", "missing_required_keys", "=", "required_keys_set", "-", "config_keys_set", "unrecognized_keys", "=", "config_keys_set", "-", "required_keys_set", "# if any missing required key raise ValidationError", "if", "len", "(", "missing_required_keys", ")", ">", "0", ":", "# converts list in comma separated string", "missing_keys_string", "=", "', '", ".", "join", "(", "missing_required_keys", ")", "# django error", "raise", "ValidationError", "(", "_", "(", "'Missing required config keys: \"%s\"'", ")", "%", "missing_keys_string", ")", "elif", "len", "(", "unrecognized_keys", ")", ">", "0", ":", "# converts list in comma separated string", "unrecognized_keys_string", "=", "', '", ".", "join", "(", "unrecognized_keys", ")", "# django error", "raise", "ValidationError", "(", "_", "(", "'Unrecognized config keys: \"%s\"'", ")", "%", "unrecognized_keys_string", ")" ]

[ "ensure", "REQUIRED_CONFIG_KEYS", "are", "filled" ]

[ "def", "filter_pastdate", "(", "string", ",", "default", "=", "None", ")", ":", "if", "not", "string", "and", "default", "is", "not", "None", ":", "return", "default", "today", "=", "datetime", ".", "date", ".", "today", "(", ")", "# split the string", "try", ":", "parts", "=", "map", "(", "int", ",", "re", ".", "split", "(", "'\\D+'", ",", "string", ")", ")", "# split the string", "except", "ValueError", ":", "raise", "InvalidInputError", "(", "\"invalid date; use format: DD [MM [YYYY]]\"", ")", "if", "len", "(", "parts", ")", "<", "1", "or", "len", "(", "parts", ")", ">", "3", ":", "raise", "InvalidInputError", "(", "\"invalid date; use format: DD [MM [YYYY]]\"", ")", "if", "len", "(", "parts", ")", "==", "1", ":", "# no month or year given; append month", "parts", ".", "append", "(", "today", ".", "month", "-", "1", "if", "parts", "[", "0", "]", ">", "today", ".", "day", "else", "today", ".", "month", ")", "if", "parts", "[", "1", "]", "<", "1", ":", "parts", "[", "1", "]", "=", "12", "if", "len", "(", "parts", ")", "==", "2", ":", "# no year given; append year", "if", "parts", "[", "1", "]", ">", "today", ".", "month", "or", "parts", "[", "1", "]", "==", "today", ".", "month", "and", "parts", "[", "0", "]", ">", "today", ".", "day", ":", "parts", ".", "append", "(", "today", ".", "year", "-", "1", ")", "else", ":", "parts", ".", "append", "(", "today", ".", "year", ")", "parts", ".", "reverse", "(", ")", "try", ":", "date", "=", "datetime", ".", "date", "(", "*", "parts", ")", "if", "date", ">", "today", ":", "raise", "InvalidInputError", "(", "\"cannot choose a date in the future\"", ")", "return", "date", "except", "ValueError", ":", "print", "parts", "raise", "InvalidInputError", "(", "\"invalid date; use format: DD [MM [YYYY]]\"", ")" ]

[ "Coerce", "to", "a", "date", "not", "beyond", "the", "current", "date" ]

[ "def", "lock", "(", "self", ")", ":", "data", "=", "self", ".", "data", "data", "[", "'_meta'", "]", "[", "'hash'", "]", "=", "{", "\"sha256\"", ":", "self", ".", "hash", "}", "data", "[", "'_meta'", "]", "[", "'pipfile-spec'", "]", "=", "6", "return", "json", ".", "dumps", "(", "data", ",", "indent", "=", "4", ",", "separators", "=", "(", "','", ",", "': '", ")", ")" ]

[ "Returns", "a", "JSON", "representation", "of", "the", "Pipfile", "." ]

[ "def", "get_inputs_for_state", "(", "self", ",", "state", ")", ":", "result_dict", "=", "{", "}", "tmp_dict", "=", "self", ".", "get_default_input_values_for_state", "(", "state", ")", "result_dict", ".", "update", "(", "tmp_dict", ")", "for", "input_port_key", ",", "value", "in", "state", ".", "input_data_ports", ".", "items", "(", ")", ":", "# for all input keys fetch the correct data_flow connection and read data into the result_dict", "actual_value", "=", "None", "actual_value_time", "=", "0", "for", "data_flow_key", ",", "data_flow", "in", "self", ".", "data_flows", ".", "items", "(", ")", ":", "if", "data_flow", ".", "to_key", "==", "input_port_key", ":", "if", "data_flow", ".", "to_state", "==", "state", ".", "state_id", ":", "# fetch data from the scoped_data list: the key is the data_port_key + the state_id", "key", "=", "str", "(", "data_flow", ".", "from_key", ")", "+", "data_flow", ".", "from_state", "if", "key", "in", "self", ".", "scoped_data", ":", "if", "actual_value", "is", "None", "or", "actual_value_time", "<", "self", ".", "scoped_data", "[", "key", "]", ".", "timestamp", ":", "actual_value", "=", "deepcopy", "(", "self", ".", "scoped_data", "[", "key", "]", ".", "value", ")", "actual_value_time", "=", "self", ".", "scoped_data", "[", "key", "]", ".", "timestamp", "if", "actual_value", "is", "not", "None", ":", "result_dict", "[", "value", ".", "name", "]", "=", "actual_value", "return", "result_dict" ]

[ "Retrieves", "all", "input", "data", "of", "a", "state", ".", "If", "several", "data", "flows", "are", "connected", "to", "an", "input", "port", "the", "most", "current", "data", "is", "used", "for", "the", "specific", "input", "port", "." ]

[ "def", "run", "(", "self", ",", "event", ",", "lambda_context", ")", ":", "from", "c7n", ".", "actions", "import", "EventAction", "mode", "=", "self", ".", "policy", ".", "data", ".", "get", "(", "'mode'", ",", "{", "}", ")", "if", "not", "bool", "(", "mode", ".", "get", "(", "\"log\"", ",", "True", ")", ")", ":", "root", "=", "logging", ".", "getLogger", "(", ")", "map", "(", "root", ".", "removeHandler", ",", "root", ".", "handlers", "[", ":", "]", ")", "root", ".", "handlers", "=", "[", "logging", ".", "NullHandler", "(", ")", "]", "resources", "=", "self", ".", "resolve_resources", "(", "event", ")", "if", "not", "resources", ":", "return", "resources", "resources", "=", "self", ".", "policy", ".", "resource_manager", ".", "filter_resources", "(", "resources", ",", "event", ")", "if", "'debug'", "in", "event", ":", "self", ".", "policy", ".", "log", ".", "info", "(", "\"Filtered resources %d\"", "%", "len", "(", "resources", ")", ")", "if", "not", "resources", ":", "self", ".", "policy", ".", "log", ".", "info", "(", "\"policy: %s resources: %s no resources matched\"", "%", "(", "self", ".", "policy", ".", "name", ",", "self", ".", "policy", ".", "resource_type", ")", ")", "return", "with", "self", ".", "policy", ".", "ctx", ":", "self", ".", "policy", ".", "ctx", ".", "metrics", ".", "put_metric", "(", "'ResourceCount'", ",", "len", "(", "resources", ")", ",", "'Count'", ",", "Scope", "=", "\"Policy\"", ",", "buffer", "=", "False", ")", "if", "'debug'", "in", "event", ":", "self", ".", "policy", ".", "log", ".", "info", "(", "\"Invoking actions %s\"", ",", "self", ".", "policy", ".", "resource_manager", ".", "actions", ")", "self", ".", "policy", ".", "_write_file", "(", "'resources.json'", ",", "utils", ".", "dumps", "(", "resources", ",", "indent", "=", "2", ")", ")", "for", "action", "in", "self", ".", "policy", ".", "resource_manager", ".", "actions", ":", "self", ".", "policy", ".", "log", ".", "info", "(", "\"policy: %s invoking action: %s resources: %d\"", ",", "self", ".", "policy", ".", "name", ",", "action", ".", "name", ",", "len", "(", "resources", ")", ")", "if", "isinstance", "(", "action", ",", "EventAction", ")", ":", "results", "=", "action", ".", "process", "(", "resources", ",", "event", ")", "else", ":", "results", "=", "action", ".", "process", "(", "resources", ")", "self", ".", "policy", ".", "_write_file", "(", "\"action-%s\"", "%", "action", ".", "name", ",", "utils", ".", "dumps", "(", "results", ")", ")", "return", "resources" ]

[ "Run", "policy", "in", "push", "mode", "against", "given", "event", "." ]

[ "def", "after_loop", "(", "self", ",", "coro", ")", ":", "if", "not", "(", "inspect", ".", "iscoroutinefunction", "(", "coro", ")", "or", "inspect", ".", "isawaitable", "(", "coro", ")", ")", ":", "raise", "TypeError", "(", "'Expected coroutine or awaitable, received {0.__name__!r}.'", ".", "format", "(", "type", "(", "coro", ")", ")", ")", "self", ".", "_after_loop", "=", "coro" ]

[ "A", "function", "that", "also", "acts", "as", "a", "decorator", "to", "register", "a", "coroutine", "to", "be", "called", "after", "the", "loop", "finished", "running", "." ]

[ "def", "normalize_query_parameters", "(", "query_string", ")", ":", "if", "query_string", "==", "\"\"", ":", "return", "{", "}", "components", "=", "query_string", ".", "split", "(", "\"&\"", ")", "result", "=", "{", "}", "for", "component", "in", "components", ":", "try", ":", "key", ",", "value", "=", "component", ".", "split", "(", "\"=\"", ",", "1", ")", "except", "ValueError", ":", "key", "=", "component", "value", "=", "\"\"", "if", "component", "==", "\"\"", ":", "# Empty component; skip it.", "continue", "key", "=", "normalize_uri_path_component", "(", "key", ")", "value", "=", "normalize_uri_path_component", "(", "value", ")", "if", "key", "in", "result", ":", "result", "[", "key", "]", ".", "append", "(", "value", ")", "else", ":", "result", "[", "key", "]", "=", "[", "value", "]", "return", "dict", "(", "[", "(", "key", ",", "sorted", "(", "values", ")", ")", "for", "key", ",", "values", "in", "iteritems", "(", "result", ")", "]", ")" ]

[ "normalize_query_parameters", "(", "query_string", ")", "-", ">", "dict" ]

[ "def", "getCallList", "(", "self", ",", "timeout", "=", "1", ")", ":", "namespace", "=", "Fritz", ".", "getServiceType", "(", "\"getCallList\"", ")", "uri", "=", "self", ".", "getControlURL", "(", "namespace", ")", "results", "=", "self", ".", "execute", "(", "uri", ",", "namespace", ",", "\"GetCallList\"", ")", "# setup proxies", "proxies", "=", "{", "}", "if", "self", ".", "httpProxy", ":", "proxies", "=", "{", "\"https\"", ":", "self", ".", "httpProxy", "}", "if", "self", ".", "httpsProxy", ":", "proxies", "=", "{", "\"http\"", ":", "self", ".", "httpsProxy", "}", "# get the content", "request", "=", "requests", ".", "get", "(", "results", "[", "\"NewCallListURL\"", "]", ",", "proxies", "=", "proxies", ",", "timeout", "=", "float", "(", "timeout", ")", ")", "if", "request", ".", "status_code", "!=", "200", ":", "errorStr", "=", "DeviceTR64", ".", "_extractErrorString", "(", "request", ")", "raise", "ValueError", "(", "'Could not get CPE definitions \"'", "+", "results", "[", "\"NewCallListURL\"", "]", "+", "'\" : '", "+", "str", "(", "request", ".", "status_code", ")", "+", "' - '", "+", "request", ".", "reason", "+", "\" -- \"", "+", "errorStr", ")", "# parse xml", "try", ":", "root", "=", "ET", ".", "fromstring", "(", "request", ".", "text", ".", "encode", "(", "'utf-8'", ")", ")", "except", "Exception", "as", "e", ":", "raise", "ValueError", "(", "\"Could not parse call list '\"", "+", "results", "[", "\"NewCallListURL\"", "]", "+", "\"': \"", "+", "str", "(", "e", ")", ")", "calls", "=", "[", "]", "for", "child", "in", "root", ".", "getchildren", "(", ")", ":", "if", "child", ".", "tag", ".", "lower", "(", ")", "==", "\"call\"", ":", "callParameters", "=", "{", "}", "for", "callChild", "in", "child", ".", "getchildren", "(", ")", ":", "callParameters", "[", "callChild", ".", "tag", "]", "=", "callChild", ".", "text", "calls", ".", "append", "(", "callParameters", ")", "return", "calls" ]

[ "Get", "the", "list", "of", "phone", "calls", "made" ]

[ "def", "show_item_v3", "(", "h", ")", ":", "st", "=", "rar3_type", "(", "h", ".", "type", ")", "xprint", "(", "\"%s: hdrlen=%d datlen=%d\"", ",", "st", ",", "h", ".", "header_size", ",", "h", ".", "add_size", ")", "if", "h", ".", "type", "in", "(", "rf", ".", "RAR_BLOCK_FILE", ",", "rf", ".", "RAR_BLOCK_SUB", ")", ":", "if", "h", ".", "host_os", "==", "rf", ".", "RAR_OS_UNIX", ":", "s_mode", "=", "\"0%o\"", "%", "h", ".", "mode", "else", ":", "s_mode", "=", "\"0x%x\"", "%", "h", ".", "mode", "xprint", "(", "\" flags=0x%04x:%s\"", ",", "h", ".", "flags", ",", "get_file_flags", "(", "h", ".", "flags", ")", ")", "if", "h", ".", "host_os", ">=", "0", "and", "h", ".", "host_os", "<", "len", "(", "os_list", ")", ":", "s_os", "=", "os_list", "[", "h", ".", "host_os", "]", "else", ":", "s_os", "=", "\"?\"", "xprint", "(", "\" os=%d:%s ver=%d mode=%s meth=%c cmp=%d dec=%d vol=%d\"", ",", "h", ".", "host_os", ",", "s_os", ",", "h", ".", "extract_version", ",", "s_mode", ",", "h", ".", "compress_type", ",", "h", ".", "compress_size", ",", "h", ".", "file_size", ",", "h", ".", "volume", ")", "ucrc", "=", "(", "h", ".", "CRC", "+", "(", "1", "<<", "32", ")", ")", "&", "(", "(", "1", "<<", "32", ")", "-", "1", ")", "xprint", "(", "\" crc=0x%08x (%d) date_time=%s\"", ",", "ucrc", ",", "h", ".", "CRC", ",", "fmt_time", "(", "h", ".", "date_time", ")", ")", "xprint", "(", "\" name=%s\"", ",", "h", ".", "filename", ")", "if", "h", ".", "mtime", ":", "xprint", "(", "\" mtime=%s\"", ",", "fmt_time", "(", "h", ".", "mtime", ")", ")", "if", "h", ".", "ctime", ":", "xprint", "(", "\" ctime=%s\"", ",", "fmt_time", "(", "h", ".", "ctime", ")", ")", "if", "h", ".", "atime", ":", "xprint", "(", "\" atime=%s\"", ",", "fmt_time", "(", "h", ".", "atime", ")", ")", "if", "h", ".", "arctime", ":", "xprint", "(", "\" arctime=%s\"", ",", "fmt_time", "(", "h", ".", "arctime", ")", ")", "elif", "h", ".", "type", "==", "rf", ".", "RAR_BLOCK_MAIN", ":", "xprint", "(", "\" flags=0x%04x:%s\"", ",", "h", ".", "flags", ",", "render_flags", "(", "h", ".", "flags", ",", "main_bits", ")", ")", "elif", "h", ".", "type", "==", "rf", ".", "RAR_BLOCK_ENDARC", ":", "xprint", "(", "\" flags=0x%04x:%s\"", ",", "h", ".", "flags", ",", "render_flags", "(", "h", ".", "flags", ",", "endarc_bits", ")", ")", "elif", "h", ".", "type", "==", "rf", ".", "RAR_BLOCK_MARK", ":", "xprint", "(", "\" flags=0x%04x:\"", ",", "h", ".", "flags", ")", "else", ":", "xprint", "(", "\" flags=0x%04x:%s\"", ",", "h", ".", "flags", ",", "render_flags", "(", "h", ".", "flags", ",", "generic_bits", ")", ")", "if", "h", ".", "comment", "is", "not", "None", ":", "cm", "=", "repr", "(", "h", ".", "comment", ")", "if", "cm", "[", "0", "]", "==", "'u'", ":", "cm", "=", "cm", "[", "1", ":", "]", "xprint", "(", "\" comment=%s\"", ",", "cm", ")" ]

[ "Show", "any", "RAR3", "record", "." ]

[ "def", "to_basestring", "(", "value", ")", ":", "if", "isinstance", "(", "value", ",", "_BASESTRING_TYPES", ")", ":", "return", "value", "assert", "isinstance", "(", "value", ",", "bytes", ")", "return", "value", ".", "decode", "(", "\"utf-8\"", ")" ]

[ "Converts", "a", "string", "argument", "to", "a", "subclass", "of", "basestring", "." ]

[ "def", "approve_subscription", "(", "data", ")", ":", "url", "=", "data", "[", "'SubscribeURL'", "]", "domain", "=", "urlparse", "(", "url", ")", ".", "netloc", "pattern", "=", "getattr", "(", "settings", ",", "'BOUNCY_SUBSCRIBE_DOMAIN_REGEX'", ",", "r\"sns.[a-z0-9\\-]+.amazonaws.com$\"", ")", "if", "not", "re", ".", "search", "(", "pattern", ",", "domain", ")", ":", "logger", ".", "error", "(", "'Invalid Subscription Domain %s'", ",", "url", ")", "return", "HttpResponseBadRequest", "(", "'Improper Subscription Domain'", ")", "try", ":", "result", "=", "urlopen", "(", "url", ")", ".", "read", "(", ")", "logger", ".", "info", "(", "'Subscription Request Sent %s'", ",", "url", ")", "except", "urllib", ".", "HTTPError", "as", "error", ":", "result", "=", "error", ".", "read", "(", ")", "logger", ".", "warning", "(", "'HTTP Error Creating Subscription %s'", ",", "str", "(", "result", ")", ")", "signals", ".", "subscription", ".", "send", "(", "sender", "=", "'bouncy_approve_subscription'", ",", "result", "=", "result", ",", "notification", "=", "data", ")", "# Return a 200 Status Code", "return", "HttpResponse", "(", "six", ".", "u", "(", "result", ")", ")" ]

[ "Function", "to", "approve", "a", "SNS", "subscription", "with", "Amazon" ]

[ "def", "process_frame", "(", "self", ",", "f", ",", "frame_str", ")", ":", "frame_type", "=", "f", ".", "cmd", ".", "lower", "(", ")", "if", "frame_type", "in", "[", "'disconnect'", "]", ":", "return", "if", "frame_type", "==", "'send'", ":", "frame_type", "=", "'message'", "f", ".", "cmd", "=", "'MESSAGE'", "if", "frame_type", "in", "[", "'connected'", ",", "'message'", ",", "'receipt'", ",", "'error'", ",", "'heartbeat'", "]", ":", "if", "frame_type", "==", "'message'", ":", "if", "f", ".", "headers", "[", "'destination'", "]", "not", "in", "self", ".", "subscriptions", ".", "values", "(", ")", ":", "return", "(", "f", ".", "headers", ",", "f", ".", "body", ")", "=", "self", ".", "notify", "(", "'before_message'", ",", "f", ".", "headers", ",", "f", ".", "body", ")", "self", ".", "notify", "(", "frame_type", ",", "f", ".", "headers", ",", "f", ".", "body", ")", "if", "'receipt'", "in", "f", ".", "headers", ":", "receipt_frame", "=", "Frame", "(", "'RECEIPT'", ",", "{", "'receipt-id'", ":", "f", ".", "headers", "[", "'receipt'", "]", "}", ")", "lines", "=", "convert_frame", "(", "receipt_frame", ")", "self", ".", "send", "(", "encode", "(", "pack", "(", "lines", ")", ")", ")", "log", ".", "debug", "(", "\"Received frame: %r, headers=%r, body=%r\"", ",", "f", ".", "cmd", ",", "f", ".", "headers", ",", "f", ".", "body", ")" ]

[ ":", "param", "Frame", "f", ":", "Frame", "object", ":", "param", "bytes", "frame_str", ":", "Raw", "frame", "content" ]

[ "def", "join", "(", "self", ")", ":", "self", ".", "_future", "=", "False", "self", ".", "_job", ".", "poll", "(", ")", "model_key", "=", "self", ".", "_job", ".", "dest_key", "self", ".", "_job", "=", "None", "model_json", "=", "h2o", ".", "api", "(", "\"GET /%d/Models/%s\"", "%", "(", "self", ".", "_rest_version", ",", "model_key", ")", ")", "[", "\"models\"", "]", "[", "0", "]", "self", ".", "_resolve_model", "(", "model_key", ",", "model_json", ")" ]

[ "Wait", "until", "job", "s", "completion", "." ]

[ "def", "derived_from", "(", "self", ",", "identity", ":", "QualName", ")", "->", "MutableSet", "[", "QualName", "]", ":", "try", ":", "res", "=", "self", ".", "identity_adjs", "[", "identity", "]", ".", "derivs", "except", "KeyError", ":", "return", "set", "(", ")", "for", "id", "in", "res", ".", "copy", "(", ")", ":", "res", "|=", "self", ".", "derived_from", "(", "id", ")", "return", "res" ]

[ "Return", "list", "of", "identities", "transitively", "derived", "from", "identity", "." ]

[ "def", "get_proxy_session", "(", "self", ")", ":", "if", "not", "self", ".", "supports_proxy", "(", ")", ":", "raise", "Unimplemented", "(", ")", "try", ":", "from", ".", "import", "sessions", "except", "ImportError", ":", "raise", "# OperationFailed()", "try", ":", "session", "=", "sessions", ".", "ProxySession", "(", ")", "except", "AttributeError", ":", "raise", "# OperationFailed()", "return", "session" ]

[ "Gets", "a", "ProxySession", "which", "is", "responsible", "for", "acquiring", "authentication", "credentials", "on", "behalf", "of", "a", "service", "client", "." ]

[ "def", "regret", "(", "self", ")", ":", "return", "(", "sum", "(", "self", ".", "pulls", ")", "*", "np", ".", "max", "(", "np", ".", "nan_to_num", "(", "self", ".", "wins", "/", "self", ".", "pulls", ")", ")", "-", "sum", "(", "self", ".", "wins", ")", ")", "/", "sum", "(", "self", ".", "pulls", ")" ]

[ "Calculate", "expected", "regret", "where", "expected", "regret", "is", "maximum", "optimal", "reward", "-", "sum", "of", "collected", "rewards", "i", ".", "e", "." ]

[ "def", "encrypt", "(", "self", ")", ":", "value", "=", "self", ".", "parameters", ".", "get", "(", "\"Plaintext\"", ")", "if", "isinstance", "(", "value", ",", "six", ".", "text_type", ")", ":", "value", "=", "value", ".", "encode", "(", "'utf-8'", ")", "return", "json", ".", "dumps", "(", "{", "\"CiphertextBlob\"", ":", "base64", ".", "b64encode", "(", "value", ")", ".", "decode", "(", "\"utf-8\"", ")", ",", "'KeyId'", ":", "'key_id'", "}", ")" ]

[ "We", "perform", "no", "encryption", "we", "just", "encode", "the", "value", "as", "base64", "and", "then", "decode", "it", "in", "decrypt", "()", "." ]

[ "def", "_proc_node_stmt", "(", "self", ",", "toks", ")", ":", "opts", "=", "toks", "[", "1", "]", "dummy_node", "=", "Node", "(", "\"dummy\"", ")", "# Coerce attribute types.", "for", "key", ",", "value", "in", "opts", ".", "iteritems", "(", ")", ":", "trait", "=", "dummy_node", ".", "trait", "(", "key", ")", "if", "trait", "is", "not", "None", ":", "if", "trait", ".", "is_trait_type", "(", "Float", ")", ":", "opts", "[", "key", "]", "=", "float", "(", "value", ")", "elif", "trait", ".", "is_trait_type", "(", "Tuple", ")", ":", "opts", "[", "key", "]", "=", "tuple", "(", "[", "float", "(", "c", ")", "for", "c", "in", "value", ".", "split", "(", "\",\"", ")", "]", ")", "return", "super", "(", "GodotDataParser", ",", "self", ")", ".", "_proc_node_stmt", "(", "toks", ")" ]

[ "Return", "(", "ADD_NODE", "node_name", "options", ")" ]

[ "def", "run_from_cli", "(", ")", ":", "arg_parser", "=", "argparse", ".", "ArgumentParser", "(", "description", "=", "'Read and write properties in a wp-config.php file. '", "'Include a --value argument to set the value, omit it to '", "'read the value of the specified key.'", ",", "prog", "=", "'python -m wpconfigr'", ")", "arg_parser", ".", "add_argument", "(", "'--filename'", ",", "help", "=", "'wp-config.php filename'", ",", "required", "=", "True", ")", "arg_parser", ".", "add_argument", "(", "'--key'", ",", "help", "=", "'Property key'", ",", "required", "=", "True", ")", "arg_parser", ".", "add_argument", "(", "'--value'", ",", "help", "=", "'New property value'", ",", "required", "=", "False", ")", "arg_parser", ".", "add_argument", "(", "'--log-level'", ",", "default", "=", "'CRITICAL'", ",", "help", "=", "'Log level'", ",", "required", "=", "False", ")", "arg_parser", ".", "add_argument", "(", "'--set-true'", ",", "action", "=", "'store_true'", ",", "help", "=", "'Set the value as boolean true'", ")", "arg_parser", ".", "add_argument", "(", "'--set-false'", ",", "action", "=", "'store_true'", ",", "help", "=", "'Set the value as boolean false'", ")", "args", "=", "arg_parser", ".", "parse_args", "(", ")", "if", "args", ".", "set_true", "and", "args", ".", "set_false", ":", "arg_parser", ".", "error", "(", "'Cannot set --set-true and --set-false.'", ")", "if", "args", ".", "value", "and", "args", ".", "set_true", ":", "arg_parser", ".", "error", "(", "'Cannot set --value and --set-true.'", ")", "if", "args", ".", "value", "and", "args", ".", "set_false", ":", "arg_parser", ".", "error", "(", "'Cannot set --value and --set-false.'", ")", "basicConfig", "(", "level", "=", "str", "(", "args", ".", "log_level", ")", ".", "upper", "(", ")", ")", "updater", "=", "WpConfigFile", "(", "filename", "=", "args", ".", "filename", ")", "if", "args", ".", "set_true", ":", "value", "=", "True", "elif", "args", ".", "set_false", ":", "value", "=", "False", "else", ":", "value", "=", "args", ".", "value", "if", "value", "is", "not", "None", ":", "updater", ".", "set", "(", "key", "=", "args", ".", "key", ",", "value", "=", "value", ")", "else", ":", "got", "=", "updater", ".", "get", "(", "key", "=", "args", ".", "key", ")", "if", "got", ":", "print", "(", "got", ")" ]

[ "Perform", "an", "update", "instigated", "from", "a", "CLI", "." ]

[ "def", "seek_file_end", "(", "file", ")", ":", "try", ":", "file", ".", "seek", "(", "0", ",", "2", ")", "except", "ValueError", ":", "# gzip files don't support seek from end", "while", "True", ":", "data", "=", "file", ".", "read", "(", "4096", ")", "if", "not", "data", ":", "break" ]

[ "Seek", "to", "the", "end", "of", "the", "file", "." ]

[ "def", "proc_check_guard", "(", "self", ",", "instance", ",", "sql", ")", ":", "self", ".", "open_db_connections", "(", "instance", ",", "self", ".", "PROC_GUARD_DB_KEY", ")", "cursor", "=", "self", ".", "get_cursor", "(", "instance", ",", "self", ".", "PROC_GUARD_DB_KEY", ")", "should_run", "=", "False", "try", ":", "cursor", ".", "execute", "(", "sql", ",", "(", ")", ")", "result", "=", "cursor", ".", "fetchone", "(", ")", "should_run", "=", "result", "[", "0", "]", "==", "1", "except", "Exception", "as", "e", ":", "self", ".", "log", ".", "error", "(", "\"Failed to run proc_only_if sql {} : {}\"", ".", "format", "(", "sql", ",", "e", ")", ")", "self", ".", "close_cursor", "(", "cursor", ")", "self", ".", "close_db_connections", "(", "instance", ",", "self", ".", "PROC_GUARD_DB_KEY", ")", "return", "should_run" ]

[ "check", "to", "see", "if", "the", "guard", "SQL", "returns", "a", "single", "column", "containing", "0", "or", "1", "We", "return", "true", "if", "1", "else", "False" ]

[ "def", "index", "(", "self", ",", "elem", ")", ":", "return", "_coconut", ".", "len", "(", "self", ".", "_iter", ")", "-", "self", ".", "_iter", ".", "index", "(", "elem", ")", "-", "1" ]

[ "Find", "the", "index", "of", "elem", "in", "the", "reversed", "iterator", "." ]

[ "def", "_F", "(", "x", ",", "gam", ")", ":", "beta", "=", "np", ".", "sqrt", "(", "1", "-", "gam", "**", "-", "2", ")", "B", "=", "1", "+", "0.5", "*", "(", "gam", "**", "2", "-", "1", ")", "C", "=", "10", "*", "x", "*", "gam", "*", "beta", "*", "(", "2", "+", "gam", "*", "beta", ")", "C", "/=", "1", "+", "x", "**", "2", "*", "(", "gam", "**", "2", "-", "1", ")", "F_1", "=", "(", "17", "-", "3", "*", "x", "**", "2", "/", "(", "2", "-", "x", ")", "**", "2", "-", "C", ")", "*", "np", ".", "sqrt", "(", "1", "-", "x", ")", "F_2", "=", "12", "*", "(", "2", "-", "x", ")", "-", "7", "*", "x", "**", "2", "/", "(", "2", "-", "x", ")", "-", "3", "*", "x", "**", "4", "/", "(", "2", "-", "x", ")", "**", "3", "F_3", "=", "np", ".", "log", "(", "(", "1", "+", "np", ".", "sqrt", "(", "1", "-", "x", ")", ")", "/", "np", ".", "sqrt", "(", "x", ")", ")", "return", "B", "*", "F_1", "+", "F_2", "*", "F_3" ]

[ "Eqs", ".", "A6", "A7", "of", "Baring", "et", "al", ".", "(", "1999", ")" ]

[ "def", "bundle_apps", "(", "self", ",", "bundle_name", ",", "bundle_apps", ")", ":", "bundle_file", "=", "os", ".", "path", ".", "join", "(", "self", ".", "app_path", ",", "self", ".", "args", ".", "outdir", ",", "'{}-bundle.zip'", ".", "format", "(", "bundle_name", ")", ")", "z", "=", "zipfile", ".", "ZipFile", "(", "bundle_file", ",", "'w'", ")", "for", "app", "in", "bundle_apps", ":", "# update package data", "self", ".", "package_data", "[", "'bundle'", "]", ".", "append", "(", "{", "'action'", ":", "'Adding App:'", ",", "'output'", ":", "os", ".", "path", ".", "basename", "(", "app", ")", "}", ")", "z", ".", "write", "(", "app", ",", "os", ".", "path", ".", "basename", "(", "app", ")", ")", "# update package data", "self", ".", "package_data", "[", "'bundle'", "]", ".", "append", "(", "{", "'action'", ":", "'Created Bundle:'", ",", "'output'", ":", "os", ".", "path", ".", "basename", "(", "bundle_file", ")", "}", ")", "z", ".", "close", "(", ")" ]

[ "Bundle", "multiple", "Job", "or", "Playbook", "Apps", "(", ".", "tcx", "files", ")", "into", "a", "single", "zip", "file", "." ]

[ "def", "is_structured_array", "(", "obj", ")", ":", "if", "isinstance", "(", "obj", ",", "np", ".", "ndarray", ")", "and", "hasattr", "(", "obj", ",", "'dtype'", ")", ":", "if", "obj", ".", "dtype", ".", "names", "is", "not", "None", ":", "return", "True", "return", "False" ]

[ "Returns", "True", "if", "the", "given", "object", "is", "a", "Numpy", "Structured", "Array", "." ]

[ "def", "send_stderr", "(", "self", ",", "s", ")", ":", "size", "=", "len", "(", "s", ")", "self", ".", "lock", ".", "acquire", "(", ")", "try", ":", "size", "=", "self", ".", "_wait_for_send_window", "(", "size", ")", "if", "size", "==", "0", ":", "# eof or similar", "return", "0", "m", "=", "Message", "(", ")", "m", ".", "add_byte", "(", "cMSG_CHANNEL_EXTENDED_DATA", ")", "m", ".", "add_int", "(", "self", ".", "remote_chanid", ")", "m", ".", "add_int", "(", "1", ")", "m", ".", "add_string", "(", "s", "[", ":", "size", "]", ")", "finally", ":", "self", ".", "lock", ".", "release", "(", ")", "# Note: We release self.lock before calling _send_user_message.", "# Otherwise, we can deadlock during re-keying.", "self", ".", "transport", ".", "_send_user_message", "(", "m", ")", "return", "size" ]

[ "Send", "data", "to", "the", "channel", "on", "the", "stderr", "stream", ".", "This", "is", "normally", "only", "used", "by", "servers", "to", "send", "output", "from", "shell", "commands", "--", "clients", "won", "t", "use", "this", ".", "Returns", "the", "number", "of", "bytes", "sent", "or", "0", "if", "the", "channel", "stream", "is", "closed", ".", "Applications", "are", "responsible", "for", "checking", "that", "all", "data", "has", "been", "sent", ":", "if", "only", "some", "of", "the", "data", "was", "transmitted", "the", "application", "needs", "to", "attempt", "delivery", "of", "the", "remaining", "data", ".", ":", "param", "str", "s", ":", "data", "to", "send", ".", ":", "return", ":", "number", "of", "bytes", "actually", "sent", "as", "an", "int", ".", ":", "raises", "socket", ".", "timeout", ":", "if", "no", "data", "could", "be", "sent", "before", "the", "timeout", "set", "by", "settimeout", ".", "..", "versionadded", "::", "1", ".", "1" ]

[ "def", "ajax_editable_boolean", "(", "attr", ",", "short_description", ")", ":", "def", "_fn", "(", "self", ",", "item", ")", ":", "return", "ajax_editable_boolean_cell", "(", "item", ",", "attr", ")", "_fn", ".", "allow_tags", "=", "True", "_fn", ".", "short_description", "=", "short_description", "_fn", ".", "editable_boolean_field", "=", "attr", "return", "_fn" ]

[ "Convenience", "function", ":", "Assign", "the", "return", "value", "of", "this", "method", "to", "a", "variable", "of", "your", "ModelAdmin", "class", "and", "put", "the", "variable", "name", "into", "list_display", "." ]

[ "def", "watch_module_cache_get", "(", "cache", ",", "module", ")", ":", "imp", ".", "acquire_lock", "(", ")", "try", ":", "if", "not", "hasattr", "(", "cache", ",", "\"timestamps\"", ")", ":", "cache", ".", "timestamps", "=", "{", "}", "mtime", "=", "os", ".", "path", ".", "getmtime", "(", "module", ")", "mtime", "=", "latest_submodule_time", "(", "module", ",", "mtime", ")", "if", "getattr", "(", "cache", ",", "\"config\"", ",", "False", ")", ":", "config_file", "=", "module", "[", ":", "-", "2", "]", "+", "\"yaml\"", "if", "os", ".", "path", ".", "exists", "(", "config_file", ")", ":", "# Our timestamp is the latest time of the config file or the", "# module.", "mtime", "=", "max", "(", "mtime", ",", "os", ".", "path", ".", "getmtime", "(", "config_file", ")", ")", "# If we have a config file and the timestamp is more recent than", "# the recorded timestamp, remove the config file from the list of", "# loaded files so that it will get loaded again.", "if", "config_file", "in", "cache", ".", "config_files", "and", "mtime", ">", "cache", ".", "timestamps", ".", "get", "(", "module", ",", "0", ")", ":", "del", "cache", ".", "config_files", "[", "config_file", "]", "tangelo", ".", "log", "(", "\"WATCH\"", ",", "\"Asking to reload config file %s\"", "%", "config_file", ")", "# If the timestamp is more recent than the recorded value, remove the", "# the module from our records so that it will be loaded again.", "if", "module", "in", "cache", ".", "modules", "and", "mtime", ">", "cache", ".", "timestamps", ".", "get", "(", "module", ",", "0", ")", ":", "del", "cache", ".", "modules", "[", "module", "]", "tangelo", ".", "log", "(", "\"WATCH\"", ",", "\"Asking to reload module %s\"", "%", "module", ")", "if", "module", "not", "in", "cache", ".", "timestamps", ":", "tangelo", ".", "log_info", "(", "\"WATCH\"", ",", "\"Monitoring module %s\"", "%", "module", ")", "reload_recent_submodules", "(", "module", ",", "mtime", ")", "cache", ".", "timestamps", "[", "module", "]", "=", "mtime", "service", "=", "tangelo_module_cache_get", "(", "cache", ",", "module", ")", "# Update our time based on all the modules that we may have just", "# imported. The times can change from before because python files are", "# compiled, for instance.", "mtime", "=", "latest_submodule_time", "(", "module", ",", "mtime", ")", "cache", ".", "timestamps", "[", "module", "]", "=", "mtime", "finally", ":", "imp", ".", "release_lock", "(", ")", "return", "service" ]

[ "When", "we", "ask", "to", "fetch", "a", "module", "with", "optional", "config", "file", "check", "time", "stamps", "and", "dependencies", "to", "determine", "if", "it", "should", "be", "reloaded", "or", "not", "." ]

[ "def", "low_frequency_cutoff_from_config", "(", "cp", ")", ":", "try", ":", "low_frequency_cutoff", "=", "float", "(", "cp", ".", "get", "(", "'model'", ",", "'low-frequency-cutoff'", ")", ")", "except", "(", "NoOptionError", ",", "NoSectionError", ")", "as", "e", ":", "logging", ".", "warning", "(", "\"Low frequency cutoff for calculation of inner \"", "\"product needs to be specified in config file \"", "\"under section 'model'\"", ")", "raise", "e", "except", "Exception", "as", "e", ":", "# everything the float() can throw", "logging", ".", "warning", "(", "\"Low frequency cutoff could not be \"", "\"converted to float \"", ")", "raise", "e", "return", "low_frequency_cutoff" ]

[ "Gets", "the", "low", "frequency", "cutoff", "from", "the", "given", "config", "file", "." ]

[ "def", "_traverse_nodes", "(", "self", ")", ":", "node", "=", "self", ".", "root", "stack", "=", "[", "]", "while", "stack", "or", "node", "is", "not", "None", ":", "if", "node", "is", "not", "None", ":", "stack", ".", "append", "(", "node", ")", "node", "=", "node", ".", "left", "else", ":", "node", "=", "stack", ".", "pop", "(", ")", "yield", "node", "node", "=", "node", ".", "right" ]

[ "Debugging", "function", "(", "exposes", "cython", "nodes", "as", "dummy", "nodes", ")" ]

[ "def", "wait_for_task", "(", "self", ",", "task", ",", "timeout", "=", "-", "1", ")", ":", "self", ".", "__wait_task_completion", "(", "task", ",", "timeout", ")", "task", "=", "self", ".", "get", "(", "task", ")", "logger", ".", "debug", "(", "\"Waiting for task. Percentage complete: \"", "+", "str", "(", "task", ".", "get", "(", "'computedPercentComplete'", ")", ")", ")", "logger", ".", "debug", "(", "\"Waiting for task. Task state: \"", "+", "str", "(", "task", ".", "get", "(", "'taskState'", ")", ")", ")", "task_response", "=", "self", ".", "__get_task_response", "(", "task", ")", "logger", ".", "debug", "(", "'Task completed'", ")", "return", "task_response" ]

[ "Wait", "for", "task", "execution", "and", "return", "associated", "resource", "." ]

[ "def", "get_version", "(", ")", ":", "major", "=", "ct", ".", "c_int", "(", ")", "minor", "=", "ct", ".", "c_int", "(", ")", "micro", "=", "ct", ".", "c_int", "(", ")", "dbus", ".", "dbus_get_version", "(", "ct", ".", "byref", "(", "major", ")", ",", "ct", ".", "byref", "(", "minor", ")", ",", "ct", ".", "byref", "(", "micro", ")", ")", "return", "(", "major", ".", "value", ",", "minor", ".", "value", ",", "micro", ".", "value", ")" ]

[ "returns", "the", "libdbus", "library", "version", "as", "a", "tuple", "of", "integers", "(", "major", "minor", "micro", ")", "." ]

[ "def", "do_repo_report", "(", "repos", ",", "report", "=", "'full'", ",", "output", "=", "sys", ".", "stdout", ",", "*", "args", ",", "*", "*", "kwargs", ")", ":", "for", "i", ",", "repo", "in", "enumerate", "(", "repos", ")", ":", "log", ".", "debug", "(", "str", "(", "(", "i", ",", "next", "(", "repo", ".", "origin_report", "(", ")", ")", ")", ")", ")", "try", ":", "if", "repo", "is", "not", "None", ":", "reportfunc", "=", "REPORT_TYPES", ".", "get", "(", "report", ")", "if", "reportfunc", "is", "None", ":", "raise", "Exception", "(", "\"Unrecognized report type: %r (%s)\"", "%", "(", "report", ",", "', '", ".", "join", "(", "REPORT_TYPES", ".", "keys", "(", ")", ")", ")", ")", "for", "l", "in", "reportfunc", "(", "repo", ",", "*", "args", ",", "*", "*", "kwargs", ")", ":", "print", "(", "l", ",", "file", "=", "output", ")", "except", "Exception", "as", "e", ":", "log", ".", "error", "(", "repo", ")", "log", ".", "error", "(", "report", ")", "log", ".", "error", "(", "e", ")", "raise", "yield", "repo" ]

[ "Do", "a", "repository", "report", ":", "call", "the", "report", "function", "for", "each", "Repository" ]

[ "def", "create_ticket_str", "(", "self", ",", "prefix", "=", "None", ")", ":", "if", "not", "prefix", ":", "prefix", "=", "self", ".", "model", ".", "TICKET_PREFIX", "return", "\"%s-%d-%s\"", "%", "(", "prefix", ",", "int", "(", "time", ".", "time", "(", ")", ")", ",", "get_random_string", "(", "length", "=", "self", ".", "model", ".", "TICKET_RAND_LEN", ")", ")" ]

[ "Generate", "a", "sufficiently", "opaque", "ticket", "string", "to", "ensure", "the", "ticket", "is", "not", "guessable", ".", "If", "a", "prefix", "is", "provided", "prepend", "it", "to", "the", "string", "." ]

[ "def", "from_verb", "(", "cls", ",", "verb", ")", ":", "pattern", "=", "r'^(?P<meta>[A-Z]+)(?P<version>\\d+)(?P<action>[A-Z]+)(?P<arg1>\\d+)?(\\/(?P<arg2>\\d+))?$'", "try", ":", "verb", "=", "verb", ".", "decode", "(", ")", "except", "AttributeError", ":", "pass", "match", "=", "re", ".", "match", "(", "pattern", ",", "verb", ")", "if", "not", "match", ":", "raise", "SpoolverbError", "(", "'Invalid spoolverb: {}'", ".", "format", "(", "verb", ")", ")", "data", "=", "match", ".", "groupdict", "(", ")", "meta", "=", "data", "[", "'meta'", "]", "version", "=", "data", "[", "'version'", "]", "action", "=", "data", "[", "'action'", "]", "if", "action", "==", "'EDITIONS'", ":", "num_editions", "=", "data", "[", "'arg1'", "]", "return", "cls", "(", "meta", "=", "meta", ",", "version", "=", "version", ",", "action", "=", "action", ",", "num_editions", "=", "int", "(", "num_editions", ")", ")", "elif", "action", "==", "'LOAN'", ":", "# TODO Review. Workaround for piece loans", "try", ":", "edition_num", "=", "int", "(", "data", "[", "'arg1'", "]", ")", "except", "TypeError", ":", "edition_num", "=", "0", "loan_start", "=", "data", "[", "'arg2'", "]", "[", ":", "6", "]", "loan_end", "=", "data", "[", "'arg2'", "]", "[", "6", ":", "]", "return", "cls", "(", "meta", "=", "meta", ",", "version", "=", "version", ",", "action", "=", "action", ",", "edition_num", "=", "int", "(", "edition_num", ")", ",", "loan_start", "=", "loan_start", ",", "loan_end", "=", "loan_end", ")", "elif", "action", "in", "[", "'FUEL'", ",", "'PIECE'", ",", "'CONSIGNEDREGISTRATION'", "]", ":", "# no edition number for these verbs", "return", "cls", "(", "meta", "=", "meta", ",", "version", "=", "version", ",", "action", "=", "action", ")", "else", ":", "edition_num", "=", "data", "[", "'arg1'", "]", "return", "cls", "(", "meta", "=", "meta", ",", "version", "=", "version", ",", "action", "=", "action", ",", "edition_num", "=", "int", "(", "edition_num", ")", ")" ]

[ "Constructs", "a", ":", "class", ":", "Spoolverb", "instance", "from", "the", "string", "representation", "of", "the", "given", "verb", "." ]

[ "def", "parse_value", "(", "self", ",", "val", ",", "display", ",", "rawdict", "=", "0", ")", ":", "ret", "=", "{", "}", "vno", "=", "0", "for", "f", "in", "self", ".", "static_fields", ":", "# Fields without names should be ignored, and there should", "# not be any length or format fields if this function", "# ever gets called. (If there were such fields, there should", "# be a matching field in var_fields and then parse_binary", "# would have been called instead.", "if", "not", "f", ".", "name", ":", "pass", "elif", "isinstance", "(", "f", ",", "LengthField", ")", ":", "pass", "elif", "isinstance", "(", "f", ",", "FormatField", ")", ":", "pass", "# Value fields", "else", ":", "# If this field has a parse_value method, call it, otherwise", "# use the unpacked value as is.", "if", "f", ".", "structvalues", "==", "1", ":", "field_val", "=", "val", "[", "vno", "]", "else", ":", "field_val", "=", "val", "[", "vno", ":", "vno", "+", "f", ".", "structvalues", "]", "if", "f", ".", "parse_value", "is", "not", "None", ":", "field_val", "=", "f", ".", "parse_value", "(", "field_val", ",", "display", ",", "rawdict", "=", "rawdict", ")", "ret", "[", "f", ".", "name", "]", "=", "field_val", "vno", "=", "vno", "+", "f", ".", "structvalues", "if", "not", "rawdict", ":", "return", "DictWrapper", "(", "ret", ")", "return", "ret" ]

[ "This", "function", "is", "used", "by", "List", "and", "Object", "fields", "to", "convert", "Struct", "objects", "with", "no", "var_fields", "into", "Python", "values", "." ]