Datasets:

kejian

/

codesearchnet-python-raw

like 1

[ "def", "Define", "(", "self", ",", "name", ",", "value", "=", "None", ",", "comment", "=", "None", ")", ":", "lines", "=", "[", "]", "if", "comment", ":", "comment_str", "=", "\"/* %s */\"", "%", "comment", "lines", ".", "append", "(", "comment_str", ")", "if", "value", "is", "not", "None", ":", "define_str", "=", "\"#define %s %s\"", "%", "(", "name", ",", "value", ")", "else", ":", "define_str", "=", "\"#define %s\"", "%", "name", "lines", ".", "append", "(", "define_str", ")", "lines", ".", "append", "(", "''", ")", "self", ".", "config_h_text", "=", "self", ".", "config_h_text", "+", "'\\n'", ".", "join", "(", "lines", ")" ]

[ "Define", "a", "pre", "processor", "symbol", "name", "with", "the", "optional", "given", "value", "in", "the", "current", "config", "header", "." ]

[ "def", "as_dict", "(", "self", ")", ":", "info", "=", "{", "}", "info", "[", "\"type\"", "]", "=", "self", ".", "__class__", ".", "__name__", "info", "[", "\"help\"", "]", "=", "self", ".", "help", "info", "[", "\"default\"", "]", "=", "self", ".", "default", "info", "[", "\"multi\"", "]", "=", "self", ".", "multi", "info", "[", "\"uniq\"", "]", "=", "self", ".", "uniq", "info", "[", "\"choices\"", "]", "=", "self", ".", "choices", "# TODO appel rec sur les attrs", "#info[\"attrs\"] = self.attrs", "return", "info" ]

[ "returns", "a", "dictionary", "view", "of", "the", "option", ":", "returns", ":", "the", "option", "converted", "in", "a", "dict", ":", "rtype", ":", "dict" ]

[ "def", "absorb", "(", "self", ",", "trits", ",", "offset", "=", "0", ",", "length", "=", "None", ")", ":", "# type: (MutableSequence[int], int, Optional[int]) -> None", "# Pad input if necessary, so that it can be divided evenly into", "# hashes.", "# Note that this operation creates a COPY of ``trits``; the", "# incoming buffer is not modified!", "pad", "=", "(", "(", "len", "(", "trits", ")", "%", "TRIT_HASH_LENGTH", ")", "or", "TRIT_HASH_LENGTH", ")", "trits", "+=", "[", "0", "]", "*", "(", "TRIT_HASH_LENGTH", "-", "pad", ")", "if", "length", "is", "None", ":", "length", "=", "len", "(", "trits", ")", "if", "length", "<", "1", ":", "raise", "with_context", "(", "exc", "=", "ValueError", "(", "'Invalid length passed to ``absorb``.'", ")", ",", "context", "=", "{", "'trits'", ":", "trits", ",", "'offset'", ":", "offset", ",", "'length'", ":", "length", ",", "}", ",", ")", "while", "offset", "<", "length", ":", "stop", "=", "min", "(", "offset", "+", "TRIT_HASH_LENGTH", ",", "length", ")", "# If we're copying over a full chunk, zero last trit.", "if", "stop", "-", "offset", "==", "TRIT_HASH_LENGTH", ":", "trits", "[", "stop", "-", "1", "]", "=", "0", "signed_nums", "=", "conv", ".", "convertToBytes", "(", "trits", "[", "offset", ":", "stop", "]", ")", "# Convert signed bytes into their equivalent unsigned", "# representation, in order to use Python's built-in bytes", "# type.", "unsigned_bytes", "=", "bytearray", "(", "conv", ".", "convert_sign", "(", "b", ")", "for", "b", "in", "signed_nums", ")", "self", ".", "k", ".", "update", "(", "unsigned_bytes", ")", "offset", "+=", "TRIT_HASH_LENGTH" ]

[ "Absorb", "trits", "into", "the", "sponge", "from", "a", "buffer", "." ]

[ "def", "_listen_comments", "(", "self", ")", ":", "# Collect comments in a queue", "comments_queue", "=", "Queue", "(", "maxsize", "=", "self", ".", "_n_jobs", "*", "4", ")", "threads", "=", "[", "]", "# type: List[BotQueueWorker]", "try", ":", "# Create n_jobs CommentsThreads", "for", "i", "in", "range", "(", "self", ".", "_n_jobs", ")", ":", "t", "=", "BotQueueWorker", "(", "name", "=", "'CommentThread-t-{}'", ".", "format", "(", "i", ")", ",", "jobs", "=", "comments_queue", ",", "target", "=", "self", ".", "_process_comment", ")", "t", ".", "start", "(", ")", "threads", ".", "append", "(", "t", ")", "# Iterate over all comments in the comment stream", "for", "comment", "in", "self", ".", "_reddit", ".", "subreddit", "(", "'+'", ".", "join", "(", "self", ".", "_subs", ")", ")", ".", "stream", ".", "comments", "(", ")", ":", "# Check for stopping", "if", "self", ".", "_stop", ":", "self", ".", "_do_stop", "(", "comments_queue", ",", "threads", ")", "break", "comments_queue", ".", "put", "(", "comment", ")", "self", ".", "log", ".", "debug", "(", "'Listen comments stopped'", ")", "except", "Exception", "as", "e", ":", "self", ".", "_do_stop", "(", "comments_queue", ",", "threads", ")", "self", ".", "log", ".", "error", "(", "'Exception while listening to comments:'", ")", "self", ".", "log", ".", "error", "(", "str", "(", "e", ")", ")", "self", ".", "log", ".", "error", "(", "'Waiting for 10 minutes and trying again.'", ")", "time", ".", "sleep", "(", "10", "*", "60", ")", "# Retry", "self", ".", "_listen_comments", "(", ")" ]

[ "Start", "listening", "to", "comments", "using", "a", "separate", "thread", "." ]

[ "def", "updateEntry", "(", "self", ")", ":", "# form up new entry", "title", "=", "str", "(", "self", ".", "wtitle", ".", "text", "(", ")", ")", "comment", "=", "str", "(", "self", ".", "comment_doc", ".", "toPlainText", "(", ")", ")", "# process comment string -- eliminate single newlines, make double-newlines into separate paragraphs", "# exception are paragraphs that start with \"#LOG:\", these get special treatment and the single newlines are", "# left intact", "pars", "=", "[", "]", "for", "paragraph", "in", "comment", ".", "split", "(", "\"\\n\\n\"", ")", ":", "if", "paragraph", ".", "startswith", "(", "\"LOG:\"", ")", ":", "pars", ".", "append", "(", "paragraph", ".", "replace", "(", "\"\\n\"", ",", "\"<BR>\"", ")", ")", "else", ":", "pars", ".", "append", "(", "paragraph", ".", "replace", "(", "\"\\n\"", ",", "\" \"", ")", ")", "comment", "=", "\"\\n\"", ".", "join", "(", "pars", ")", "# go through data products and decide what to do with each one", "busy", "=", "Purr", ".", "BusyIndicator", "(", ")", "# get list of DPs", "dps", ",", "updated", "=", "self", ".", "wdplv", ".", "buildDPList", "(", ")", "# emit signal for all newly-created DPs", "for", "dp", "in", "dps", ":", "if", "not", "dp", ".", "archived", ":", "self", ".", "emit", "(", "SIGNAL", "(", "\"creatingDataProduct\"", ")", ",", "dp", ".", "sourcepath", ")", "# update or return new entry", "if", "self", ".", "entry", ":", "self", ".", "entry", ".", "update", "(", "title", "=", "title", ",", "comment", "=", "comment", ",", "dps", "=", "dps", ")", "self", ".", "entry", ".", "save", "(", "refresh_index", "=", "updated", ")", "return", "self", ".", "entry", "else", ":", "return", "Purr", ".", "LogEntry", "(", "time", ".", "time", "(", ")", ",", "title", ",", "comment", ",", "dps", ")" ]

[ "Updates", "entry", "object", "with", "current", "content", "of", "dialog", ".", "In", "new", "entry", "mode", "(", "setEntry", "()", "not", "called", "so", "self", ".", "entry", "=", "None", ")", "creates", "new", "entry", "object", ".", "In", "old", "entry", "mode", "(", "setEntry", "()", "called", ")", "updates", "and", "saves", "old", "entry", "object", "." ]

[ "def", "jsonify", "(", "py_data", ",", "default", "=", "None", ",", "indent", "=", "4", ",", "sort_keys", "=", "True", ")", ":", "return", "json", ".", "dumps", "(", "py_data", ",", "default", "=", "py2json", ",", "indent", "=", "indent", ",", "sort_keys", "=", "sort_keys", ")" ]

[ "Converts", "the", "inputted", "Python", "data", "to", "JSON", "format", ".", ":", "param", "py_data", "|", "<variant", ">" ]

[ "def", "is_archived", "(", "self", ",", "experiment", ",", "ignore_missing", "=", "True", ")", ":", "if", "ignore_missing", ":", "if", "isinstance", "(", "self", ".", "config", ".", "experiments", ".", "get", "(", "experiment", ",", "True", ")", ",", "Archive", ")", ":", "return", "self", ".", "config", ".", "experiments", ".", "get", "(", "experiment", ",", "True", ")", "else", ":", "if", "isinstance", "(", "self", ".", "config", ".", "experiments", "[", "experiment", "]", ",", "Archive", ")", ":", "return", "self", ".", "config", ".", "experiments", "[", "experiment", "]" ]

[ "Convenience", "function", "to", "determine", "whether", "the", "given", "experiment", "has", "been", "archived", "already" ]

[ "def", "series", "(", "self", ")", ":", "if", "self", ".", "is_ome", ":", "series", "=", "self", ".", "_omeseries", "(", ")", "elif", "self", ".", "is_fluoview", ":", "dims", "=", "{", "b'X'", ":", "'X'", ",", "b'Y'", ":", "'Y'", ",", "b'Z'", ":", "'Z'", ",", "b'T'", ":", "'T'", ",", "b'WAVELENGTH'", ":", "'C'", ",", "b'TIME'", ":", "'T'", ",", "b'XY'", ":", "'R'", ",", "b'EVENT'", ":", "'V'", ",", "b'EXPOSURE'", ":", "'L'", "}", "mmhd", "=", "list", "(", "reversed", "(", "self", ".", "pages", "[", "0", "]", ".", "mm_header", ".", "dimensions", ")", ")", "series", "=", "[", "Record", "(", "axes", "=", "''", ".", "join", "(", "dims", ".", "get", "(", "i", "[", "0", "]", ".", "strip", "(", ")", ".", "upper", "(", ")", ",", "'O'", ")", "for", "i", "in", "mmhd", "if", "i", "[", "1", "]", ">", "1", ")", ",", "shape", "=", "tuple", "(", "int", "(", "i", "[", "1", "]", ")", "for", "i", "in", "mmhd", "if", "i", "[", "1", "]", ">", "1", ")", ",", "pages", "=", "self", ".", "pages", ",", "dtype", "=", "numpy", ".", "dtype", "(", "self", ".", "pages", "[", "0", "]", ".", "dtype", ")", ")", "]", "elif", "self", ".", "is_lsm", ":", "lsmi", "=", "self", ".", "pages", "[", "0", "]", ".", "cz_lsm_info", "axes", "=", "CZ_SCAN_TYPES", "[", "lsmi", ".", "scan_type", "]", "if", "self", ".", "pages", "[", "0", "]", ".", "is_rgb", ":", "axes", "=", "axes", ".", "replace", "(", "'C'", ",", "''", ")", ".", "replace", "(", "'XY'", ",", "'XYC'", ")", "axes", "=", "axes", "[", ":", ":", "-", "1", "]", "shape", "=", "[", "getattr", "(", "lsmi", ",", "CZ_DIMENSIONS", "[", "i", "]", ")", "for", "i", "in", "axes", "]", "pages", "=", "[", "p", "for", "p", "in", "self", ".", "pages", "if", "not", "p", ".", "is_reduced", "]", "series", "=", "[", "Record", "(", "axes", "=", "axes", ",", "shape", "=", "shape", ",", "pages", "=", "pages", ",", "dtype", "=", "numpy", ".", "dtype", "(", "pages", "[", "0", "]", ".", "dtype", ")", ")", "]", "if", "len", "(", "pages", ")", "!=", "len", "(", "self", ".", "pages", ")", ":", "# reduced RGB pages", "pages", "=", "[", "p", "for", "p", "in", "self", ".", "pages", "if", "p", ".", "is_reduced", "]", "cp", "=", "1", "i", "=", "0", "while", "cp", "<", "len", "(", "pages", ")", "and", "i", "<", "len", "(", "shape", ")", "-", "2", ":", "cp", "*=", "shape", "[", "i", "]", "i", "+=", "1", "shape", "=", "shape", "[", ":", "i", "]", "+", "list", "(", "pages", "[", "0", "]", ".", "shape", ")", "axes", "=", "axes", "[", ":", "i", "]", "+", "'CYX'", "series", ".", "append", "(", "Record", "(", "axes", "=", "axes", ",", "shape", "=", "shape", ",", "pages", "=", "pages", ",", "dtype", "=", "numpy", ".", "dtype", "(", "pages", "[", "0", "]", ".", "dtype", ")", ")", ")", "elif", "self", ".", "is_nih", ":", "series", "=", "[", "Record", "(", "pages", "=", "self", ".", "pages", ",", "shape", "=", "(", "len", "(", "self", ".", "pages", ")", ",", ")", "+", "self", ".", "pages", "[", "0", "]", ".", "shape", ",", "axes", "=", "'I'", "+", "self", ".", "pages", "[", "0", "]", ".", "axes", ",", "dtype", "=", "numpy", ".", "dtype", "(", "self", ".", "pages", "[", "0", "]", ".", "dtype", ")", ")", "]", "elif", "self", ".", "pages", "[", "0", "]", ".", "is_shaped", ":", "shape", "=", "self", ".", "pages", "[", "0", "]", ".", "tags", "[", "'image_description'", "]", ".", "value", "[", "7", ":", "-", "1", "]", "shape", "=", "tuple", "(", "int", "(", "i", ")", "for", "i", "in", "shape", ".", "split", "(", "b','", ")", ")", "series", "=", "[", "Record", "(", "pages", "=", "self", ".", "pages", ",", "shape", "=", "shape", ",", "axes", "=", "'O'", "*", "len", "(", "shape", ")", ",", "dtype", "=", "numpy", ".", "dtype", "(", "self", ".", "pages", "[", "0", "]", ".", "dtype", ")", ")", "]", "else", ":", "shapes", "=", "[", "]", "pages", "=", "{", "}", "for", "page", "in", "self", ".", "pages", ":", "shape", "=", "page", ".", "shape", "+", "(", "page", ".", "axes", ",", "page", ".", "compression", "in", "TIFF_DECOMPESSORS", ")", "if", "not", "shape", "in", "pages", ":", "shapes", ".", "append", "(", "shape", ")", "pages", "[", "shape", "]", "=", "[", "page", "]", "else", ":", "pages", "[", "shape", "]", ".", "append", "(", "page", ")", "series", "=", "[", "Record", "(", "pages", "=", "pages", "[", "s", "]", ",", "axes", "=", "(", "(", "'I'", "+", "s", "[", "-", "2", "]", ")", "if", "len", "(", "pages", "[", "s", "]", ")", ">", "1", "else", "s", "[", "-", "2", "]", ")", ",", "dtype", "=", "numpy", ".", "dtype", "(", "pages", "[", "s", "]", "[", "0", "]", ".", "dtype", ")", ",", "shape", "=", "(", "(", "len", "(", "pages", "[", "s", "]", ")", ",", ")", "+", "s", "[", ":", "-", "2", "]", "if", "len", "(", "pages", "[", "s", "]", ")", ">", "1", "else", "s", "[", ":", "-", "2", "]", ")", ")", "for", "s", "in", "shapes", "]", "return", "series" ]

[ "Return", "series", "of", "TIFFpage", "with", "compatible", "shape", "and", "properties", "." ]

[ "def", "kip_cont", "(", "self", ",", "ifig", "=", "110", ",", "modstart", "=", "0", ",", "modstop", "=", "-", "1", ",", "t0_model", "=", "0", ",", "outfile", "=", "'out.png'", ",", "xlims", "=", "None", ",", "ylims", "=", "None", ",", "xres", "=", "1000", ",", "yres", "=", "1000", ",", "ixaxis", "=", "'model_number'", ",", "mix_zones", "=", "20", ",", "burn_zones", "=", "20", ",", "plot_radius", "=", "False", ",", "engenPlus", "=", "True", ",", "engenMinus", "=", "False", ",", "landscape_plot", "=", "False", ",", "rad_lines", "=", "False", ",", "profiles", "=", "[", "]", ",", "showfig", "=", "True", ",", "outlines", "=", "True", ",", "boundaries", "=", "True", ",", "c12_boundary", "=", "False", ",", "rasterise", "=", "False", ",", "yscale", "=", "'1.'", ",", "engenlevels", "=", "None", ",", "CBM", "=", "False", ",", "fsize", "=", "14", ")", ":", "if", "ylims", "is", "None", ":", "ylims", "=", "[", "0.", ",", "0.", "]", "if", "xlims", "is", "None", ":", "xlims", "=", "[", "0.", ",", "0.", "]", "# Find correct modstart and modstop:", "mod", "=", "np", ".", "array", "(", "[", "int", "(", "i", ")", "for", "i", "in", "self", ".", "get", "(", "'model_number'", ")", "]", ")", "mod1", "=", "np", ".", "abs", "(", "mod", "-", "modstart", ")", ".", "argmin", "(", ")", "mod2", "=", "np", ".", "abs", "(", "mod", "-", "modstop", ")", ".", "argmin", "(", ")", "if", "modstart", "!=", "0", ":", "modstart", "=", "mod1", "if", "modstop", "!=", "-", "1", ":", "modstop", "=", "mod2", "xxyy", "=", "[", "self", ".", "get", "(", "'star_age'", ")", "[", "modstart", ":", "modstop", "]", ",", "self", ".", "get", "(", "'star_age'", ")", "[", "modstart", ":", "modstop", "]", "]", "mup", "=", "max", "(", "float", "(", "self", ".", "get", "(", "'star_mass'", ")", "[", "0", "]", ")", "*", "1.02", ",", "1.0", ")", "nmodels", "=", "len", "(", "self", ".", "get", "(", "'model_number'", ")", "[", "modstart", ":", "modstop", "]", ")", "if", "ylims", "==", "[", "0.", ",", "0.", "]", ":", "mup", "=", "max", "(", "float", "(", "self", ".", "get", "(", "'star_mass'", ")", "[", "0", "]", ")", "*", "1.02", ",", "1.0", ")", "mDOWN", "=", "0.", "else", ":", "mup", "=", "ylims", "[", "1", "]", "mDOWN", "=", "ylims", "[", "0", "]", "# y-axis resolution", "ny", "=", "yres", "#dy=mup/float(ny)", "dy", "=", "old_div", "(", "(", "mup", "-", "mDOWN", ")", ",", "float", "(", "ny", ")", ")", "# x-axis resolution", "maxpoints", "=", "xres", "dx", "=", "int", "(", "max", "(", "1", ",", "old_div", "(", "nmodels", ",", "maxpoints", ")", ")", ")", "#y = np.arange(0., mup, dy)", "y", "=", "np", ".", "arange", "(", "mDOWN", ",", "mup", ",", "dy", ")", "x", "=", "np", ".", "arange", "(", "0", ",", "nmodels", ",", "dx", ")", "Msol", "=", "1.98892E+33", "engenstyle", "=", "'full'", "B1", "=", "np", ".", "zeros", "(", "[", "len", "(", "y", ")", ",", "len", "(", "x", ")", "]", ",", "float", ")", "B2", "=", "np", ".", "zeros", "(", "[", "len", "(", "y", ")", ",", "len", "(", "x", ")", "]", ",", "float", ")", "try", ":", "self", ".", "get", "(", "'burn_qtop_1'", ")", "except", ":", "engenstyle", "=", "'twozone'", "if", "engenstyle", "==", "'full'", "and", "(", "engenPlus", "==", "True", "or", "engenMinus", "==", "True", ")", ":", "ulimit_array", "=", "np", ".", "array", "(", "[", "self", ".", "get", "(", "'burn_qtop_'", "+", "str", "(", "j", ")", ")", "[", "modstart", ":", "modstop", ":", "dx", "]", "*", "self", ".", "get", "(", "'star_mass'", ")", "[", "modstart", ":", "modstop", ":", "dx", "]", "for", "j", "in", "range", "(", "1", ",", "burn_zones", "+", "1", ")", "]", ")", "#ulimit_array = np.around(ulimit_array,decimals=len(str(dy))-2)", "llimit_array", "=", "np", ".", "delete", "(", "ulimit_array", ",", "-", "1", ",", "0", ")", "llimit_array", "=", "np", ".", "insert", "(", "ulimit_array", ",", "0", ",", "0.", ",", "0", ")", "#llimit_array = np.around(llimit_array,decimals=len(str(dy))-2)", "btype_array", "=", "np", ".", "array", "(", "[", "self", ".", "get", "(", "'burn_type_'", "+", "str", "(", "j", ")", ")", "[", "modstart", ":", "modstop", ":", "dx", "]", "for", "j", "in", "range", "(", "1", ",", "burn_zones", "+", "1", ")", "]", ")", "old_percent", "=", "0", "for", "i", "in", "range", "(", "len", "(", "x", ")", ")", ":", "# writing status", "percent", "=", "int", "(", "i", "*", "100", "/", "(", "len", "(", "x", ")", "-", "1", ")", ")", "if", "percent", ">=", "old_percent", "+", "5", ":", "sys", ".", "stdout", ".", "flush", "(", ")", "sys", ".", "stdout", ".", "write", "(", "\"\\r creating color map burn \"", "+", "\"...%d%%\"", "%", "percent", ")", "old_percent", "=", "percent", "for", "j", "in", "range", "(", "burn_zones", ")", ":", "if", "btype_array", "[", "j", ",", "i", "]", ">", "0.", "and", "abs", "(", "btype_array", "[", "j", ",", "i", "]", ")", "<", "99.", ":", "B1", "[", "(", "np", ".", "abs", "(", "y", "-", "llimit_array", "[", "j", "]", "[", "i", "]", ")", ")", ".", "argmin", "(", ")", ":", "(", "np", ".", "abs", "(", "y", "-", "ulimit_array", "[", "j", "]", "[", "i", "]", ")", ")", ".", "argmin", "(", ")", "+", "1", ",", "i", "]", "=", "10.0", "**", "(", "btype_array", "[", "j", ",", "i", "]", ")", "elif", "btype_array", "[", "j", ",", "i", "]", "<", "0.", "and", "abs", "(", "btype_array", "[", "j", ",", "i", "]", ")", "<", "99.", ":", "B2", "[", "(", "np", ".", "abs", "(", "y", "-", "llimit_array", "[", "j", "]", "[", "i", "]", ")", ")", ".", "argmin", "(", ")", ":", "(", "np", ".", "abs", "(", "y", "-", "ulimit_array", "[", "j", "]", "[", "i", "]", ")", ")", ".", "argmin", "(", ")", "+", "1", ",", "i", "]", "=", "10.0", "**", "(", "abs", "(", "btype_array", "[", "j", ",", "i", "]", ")", ")", "print", "(", "' \\n'", ")", "if", "engenstyle", "==", "'twozone'", "and", "(", "engenPlus", "==", "True", "or", "engenMinus", "==", "True", ")", ":", "V", "=", "np", ".", "zeros", "(", "[", "len", "(", "y", ")", ",", "len", "(", "x", ")", "]", ",", "float", ")", "old_percent", "=", "0", "for", "i", "in", "range", "(", "len", "(", "x", ")", ")", ":", "# writing status", "percent", "=", "int", "(", "i", "*", "100", "/", "(", "len", "(", "x", ")", "-", "1", ")", ")", "if", "percent", ">=", "old_percent", "+", "5", ":", "sys", ".", "stdout", ".", "flush", "(", ")", "sys", ".", "stdout", ".", "write", "(", "\"\\r creating color map1 \"", "+", "\"...%d%%\"", "%", "percent", ")", "old_percent", "=", "percent", "llimitl1", "=", "old_div", "(", "self", ".", "get", "(", "'epsnuc_M_1'", ")", "[", "modstart", ":", "modstop", "]", "[", "i", "*", "dx", "]", ",", "Msol", ")", "ulimitl1", "=", "old_div", "(", "self", ".", "get", "(", "'epsnuc_M_4'", ")", "[", "modstart", ":", "modstop", "]", "[", "i", "*", "dx", "]", ",", "Msol", ")", "llimitl2", "=", "old_div", "(", "self", ".", "get", "(", "'epsnuc_M_5'", ")", "[", "modstart", ":", "modstop", "]", "[", "i", "*", "dx", "]", ",", "Msol", ")", "ulimitl2", "=", "old_div", "(", "self", ".", "get", "(", "'epsnuc_M_8'", ")", "[", "modstart", ":", "modstop", "]", "[", "i", "*", "dx", "]", ",", "Msol", ")", "llimith1", "=", "old_div", "(", "self", ".", "get", "(", "'epsnuc_M_2'", ")", "[", "modstart", ":", "modstop", "]", "[", "i", "*", "dx", "]", ",", "Msol", ")", "ulimith1", "=", "old_div", "(", "self", ".", "get", "(", "'epsnuc_M_3'", ")", "[", "modstart", ":", "modstop", "]", "[", "i", "*", "dx", "]", ",", "Msol", ")", "llimith2", "=", "old_div", "(", "self", ".", "get", "(", "'epsnuc_M_6'", ")", "[", "modstart", ":", "modstop", "]", "[", "i", "*", "dx", "]", ",", "Msol", ")", "ulimith2", "=", "old_div", "(", "self", ".", "get", "(", "'epsnuc_M_7'", ")", "[", "modstart", ":", "modstop", "]", "[", "i", "*", "dx", "]", ",", "Msol", ")", "# lower thresh first, then upper thresh:", "if", "llimitl1", "!=", "ulimitl1", ":", "for", "k", "in", "range", "(", "ny", ")", ":", "if", "llimitl1", "<=", "y", "[", "k", "]", "and", "ulimitl1", ">", "y", "[", "k", "]", ":", "V", "[", "k", ",", "i", "]", "=", "10.", "if", "llimitl2", "!=", "ulimitl2", ":", "for", "k", "in", "range", "(", "ny", ")", ":", "if", "llimitl2", "<=", "y", "[", "k", "]", "and", "ulimitl2", ">", "y", "[", "k", "]", ":", "V", "[", "k", ",", "i", "]", "=", "10.", "if", "llimith1", "!=", "ulimith1", ":", "for", "k", "in", "range", "(", "ny", ")", ":", "if", "llimith1", "<=", "y", "[", "k", "]", "and", "ulimith1", ">", "y", "[", "k", "]", ":", "V", "[", "k", ",", "i", "]", "=", "30.", "if", "llimith2", "!=", "ulimith2", ":", "for", "k", "in", "range", "(", "ny", ")", ":", "if", "llimith2", "<=", "y", "[", "k", "]", "and", "ulimith2", ">", "y", "[", "k", "]", ":", "V", "[", "k", ",", "i", "]", "=", "30.", "print", "(", "' \\n'", ")", "mixstyle", "=", "'full'", "try", ":", "self", ".", "get", "(", "'mix_qtop_1'", ")", "except", ":", "mixstyle", "=", "'twozone'", "if", "mixstyle", "==", "'full'", ":", "old_percent", "=", "0", "Z", "=", "np", ".", "zeros", "(", "[", "len", "(", "y", ")", ",", "len", "(", "x", ")", "]", ",", "float", ")", "if", "CBM", ":", "Zcbm", "=", "np", ".", "zeros", "(", "[", "len", "(", "y", ")", ",", "len", "(", "x", ")", "]", ",", "float", ")", "ulimit_array", "=", "np", ".", "array", "(", "[", "self", ".", "get", "(", "'mix_qtop_'", "+", "str", "(", "j", ")", ")", "[", "modstart", ":", "modstop", ":", "dx", "]", "*", "self", ".", "get", "(", "'star_mass'", ")", "[", "modstart", ":", "modstop", ":", "dx", "]", "for", "j", "in", "range", "(", "1", ",", "mix_zones", "+", "1", ")", "]", ")", "llimit_array", "=", "np", ".", "delete", "(", "ulimit_array", ",", "-", "1", ",", "0", ")", "llimit_array", "=", "np", ".", "insert", "(", "ulimit_array", ",", "0", ",", "0.", ",", "0", ")", "mtype_array", "=", "np", ".", "array", "(", "[", "self", ".", "get", "(", "'mix_type_'", "+", "str", "(", "j", ")", ")", "[", "modstart", ":", "modstop", ":", "dx", "]", "for", "j", "in", "range", "(", "1", ",", "mix_zones", "+", "1", ")", "]", ")", "for", "i", "in", "range", "(", "len", "(", "x", ")", ")", ":", "# writing status", "percent", "=", "int", "(", "i", "*", "100", "/", "(", "len", "(", "x", ")", "-", "1", ")", ")", "if", "percent", ">=", "old_percent", "+", "5", ":", "sys", ".", "stdout", ".", "flush", "(", ")", "sys", ".", "stdout", ".", "write", "(", "\"\\r creating color map mix \"", "+", "\"...%d%%\"", "%", "percent", ")", "old_percent", "=", "percent", "for", "j", "in", "range", "(", "mix_zones", ")", ":", "if", "mtype_array", "[", "j", ",", "i", "]", "==", "1.", ":", "Z", "[", "(", "np", ".", "abs", "(", "y", "-", "llimit_array", "[", "j", "]", "[", "i", "]", ")", ")", ".", "argmin", "(", ")", ":", "(", "np", ".", "abs", "(", "y", "-", "ulimit_array", "[", "j", "]", "[", "i", "]", ")", ")", ".", "argmin", "(", ")", "+", "1", ",", "i", "]", "=", "1.", "if", "CBM", ":", "if", "mtype_array", "[", "j", ",", "i", "]", "==", "2.", ":", "Zcbm", "[", "(", "np", ".", "abs", "(", "y", "-", "llimit_array", "[", "j", "]", "[", "i", "]", ")", ")", ".", "argmin", "(", ")", ":", "(", "np", ".", "abs", "(", "y", "-", "ulimit_array", "[", "j", "]", "[", "i", "]", ")", ")", ".", "argmin", "(", ")", "+", "1", ",", "i", "]", "=", "1.", "print", "(", "' \\n'", ")", "if", "mixstyle", "==", "'twozone'", ":", "Z", "=", "np", ".", "zeros", "(", "[", "len", "(", "y", ")", ",", "len", "(", "x", ")", "]", ",", "float", ")", "old_percent", "=", "0", "for", "i", "in", "range", "(", "len", "(", "x", ")", ")", ":", "# writing reading status", "# writing status", "percent", "=", "int", "(", "i", "*", "100", "/", "(", "len", "(", "x", ")", "-", "1", ")", ")", "if", "percent", ">=", "old_percent", "+", "5", ":", "sys", ".", "stdout", ".", "flush", "(", ")", "sys", ".", "stdout", ".", "write", "(", "\"\\r creating color map mix \"", "+", "\"...%d%%\"", "%", "percent", ")", "old_percent", "=", "percent", "ulimit", "=", "self", ".", "get", "(", "'conv_mx1_top'", ")", "[", "modstart", ":", "modstop", "]", "[", "i", "*", "dx", "]", "*", "self", ".", "get", "(", "'star_mass'", ")", "[", "modstart", ":", "modstop", "]", "[", "i", "*", "dx", "]", "llimit", "=", "self", ".", "get", "(", "'conv_mx1_bot'", ")", "[", "modstart", ":", "modstop", "]", "[", "i", "*", "dx", "]", "*", "self", ".", "get", "(", "'star_mass'", ")", "[", "modstart", ":", "modstop", "]", "[", "i", "*", "dx", "]", "if", "llimit", "!=", "ulimit", ":", "for", "k", "in", "range", "(", "ny", ")", ":", "if", "llimit", "<=", "y", "[", "k", "]", "and", "ulimit", ">", "y", "[", "k", "]", ":", "Z", "[", "k", ",", "i", "]", "=", "1.", "ulimit", "=", "self", ".", "get", "(", "'conv_mx2_top'", ")", "[", "modstart", ":", "modstop", "]", "[", "i", "*", "dx", "]", "*", "self", ".", "get", "(", "'star_mass'", ")", "[", "modstart", ":", "modstop", "]", "[", "i", "*", "dx", "]", "llimit", "=", "self", ".", "get", "(", "'conv_mx2_bot'", ")", "[", "modstart", ":", "modstop", "]", "[", "i", "*", "dx", "]", "*", "self", ".", "get", "(", "'star_mass'", ")", "[", "modstart", ":", "modstop", "]", "[", "i", "*", "dx", "]", "if", "llimit", "!=", "ulimit", ":", "for", "k", "in", "range", "(", "ny", ")", ":", "if", "llimit", "<=", "y", "[", "k", "]", "and", "ulimit", ">", "y", "[", "k", "]", ":", "Z", "[", "k", ",", "i", "]", "=", "1.", "print", "(", "' \\n'", ")", "if", "rad_lines", "==", "True", ":", "masses", "=", "np", ".", "arange", "(", "0.1", ",", "1.5", ",", "0.1", ")", "rads", "=", "[", "[", "]", ",", "[", "]", ",", "[", "]", ",", "[", "]", ",", "[", "]", ",", "[", "]", ",", "[", "]", ",", "[", "]", ",", "[", "]", ",", "[", "]", ",", "[", "]", ",", "[", "]", ",", "[", "]", ",", "[", "]", "]", "modno", "=", "[", "]", "for", "i", "in", "range", "(", "len", "(", "profiles", ")", ")", ":", "p", "=", "mesa_profile", "(", "'./LOGS'", ",", "profiles", "[", "i", "]", ")", "modno", ".", "append", "(", "p", ".", "header_attr", "[", "'model_number'", "]", ")", "for", "j", "in", "range", "(", "len", "(", "masses", ")", ")", ":", "idx", "=", "np", ".", "abs", "(", "p", ".", "get", "(", "'mass'", ")", "-", "masses", "[", "j", "]", ")", ".", "argmin", "(", ")", "rads", "[", "j", "]", ".", "append", "(", "p", ".", "get", "(", "'radius'", ")", "[", "idx", "]", ")", "print", "(", "'engenstyle was '", ",", "engenstyle", ")", "print", "(", "'mixstyle was '", ",", "mixstyle", ")", "print", "(", "'\\n finished preparing color map'", ")", "########################################################################", "#----------------------------------plot--------------------------------#", "fig", "=", "pyl", ".", "figure", "(", "ifig", ")", "#fsize=20", "if", "landscape_plot", "==", "True", ":", "fig", ".", "set_size_inches", "(", "9", ",", "4", ")", "pl", ".", "gcf", "(", ")", ".", "subplots_adjust", "(", "bottom", "=", "0.2", ")", "pl", ".", "gcf", "(", ")", ".", "subplots_adjust", "(", "right", "=", "0.85", ")", "params", "=", "{", "'axes.labelsize'", ":", "fsize", ",", "'axes.labelsize'", ":", "fsize", ",", "'font.size'", ":", "fsize", ",", "'legend.fontsize'", ":", "fsize", ",", "'xtick.labelsize'", ":", "fsize", ",", "'ytick.labelsize'", ":", "fsize", ",", "'text.usetex'", ":", "False", "}", "pyl", ".", "rcParams", ".", "update", "(", "params", ")", "#ax=pl.axes([0.1,0.1,0.9,0.8])", "#fig=pl.figure()", "ax", "=", "pl", ".", "axes", "(", ")", "if", "ixaxis", "==", "'log_time_left'", ":", "# log of time left until core collapse", "gage", "=", "self", ".", "get", "(", "'star_age'", ")", "lage", "=", "np", ".", "zeros", "(", "len", "(", "gage", ")", ")", "agemin", "=", "max", "(", "old_div", "(", "abs", "(", "gage", "[", "-", "1", "]", "-", "gage", "[", "-", "2", "]", ")", ",", "5.", ")", ",", "1.e-10", ")", "for", "i", "in", "np", ".", "arange", "(", "len", "(", "gage", ")", ")", ":", "if", "gage", "[", "-", "1", "]", "-", "gage", "[", "i", "]", ">", "agemin", ":", "lage", "[", "i", "]", "=", "np", ".", "log10", "(", "gage", "[", "-", "1", "]", "-", "gage", "[", "i", "]", "+", "agemin", ")", "else", ":", "lage", "[", "i", "]", "=", "np", ".", "log10", "(", "agemin", ")", "xxx", "=", "lage", "[", "modstart", ":", "modstop", "]", "print", "(", "'plot versus time left'", ")", "ax", ".", "set_xlabel", "(", "'$ \\\\log_{10}(t-t_\\mathrm{end})\\ /\\ \\mathrm{[yr]}$'", ",", "fontsize", "=", "fsize", ")", "if", "xlims", "[", "1", "]", "==", "0.", ":", "xlims", "=", "[", "xxx", "[", "0", "]", ",", "xxx", "[", "-", "1", "]", "]", "elif", "ixaxis", "==", "'model_number'", ":", "xxx", "=", "self", ".", "get", "(", "'model_number'", ")", "[", "modstart", ":", "modstop", "]", "print", "(", "'plot versus model number'", ")", "ax", ".", "set_xlabel", "(", "'Model number'", ",", "fontsize", "=", "fsize", ")", "if", "xlims", "[", "1", "]", "==", "0.", ":", "xlims", "=", "[", "self", ".", "get", "(", "'model_number'", ")", "[", "modstart", "]", ",", "self", ".", "get", "(", "'model_number'", ")", "[", "modstop", "]", "]", "elif", "ixaxis", "==", "'age'", ":", "if", "t0_model", "!=", "0", ":", "t0_mod", "=", "np", ".", "abs", "(", "mod", "-", "t0_model", ")", ".", "argmin", "(", ")", "xxx", "=", "self", ".", "get", "(", "'star_age'", ")", "[", "modstart", ":", "modstop", "]", "-", "self", ".", "get", "(", "'star_age'", ")", "[", "t0_mod", "]", "print", "(", "'plot versus age'", ")", "ax", ".", "set_xlabel", "(", "'t - %.5e / [yr]'", "%", "self", ".", "get", "(", "'star_age'", ")", "[", "modstart", "]", ",", "fontsize", "=", "fsize", ")", "else", ":", "xxx", "=", "old_div", "(", "self", ".", "get", "(", "'star_age'", ")", "[", "modstart", ":", "modstop", "]", ",", "1.e6", ")", "ax", ".", "set_xlabel", "(", "'t [Myr]'", ",", "fontsize", "=", "fsize", ")", "if", "xlims", "[", "1", "]", "==", "0.", ":", "xlims", "=", "[", "xxx", "[", "0", "]", ",", "xxx", "[", "-", "1", "]", "]", "ax", ".", "set_ylabel", "(", "'", "\\m", "\\ ", "\\ ", "\\ ", "o", "dot", "]", "}", "$", "'", ",", "fontsize", "=", "fsize", ")", "# some stuff for rasterizing only the contour part of the plot, for nice, but light, eps:", "class", "ListCollection", "(", "Collection", ")", ":", "def", "__init__", "(", "self", ",", "collections", ",", "*", "*", "kwargs", ")", ":", "Collection", ".", "__init__", "(", "self", ",", "*", "*", "kwargs", ")", "self", ".", "set_collections", "(", "collections", ")", "def", "set_collections", "(", "self", ",", "collections", ")", ":", "self", ".", "_collections", "=", "collections", "def", "get_collections", "(", "self", ")", ":", "return", "self", ".", "_collections", "@", "allow_rasterization", "def", "draw", "(", "self", ",", "renderer", ")", ":", "for", "_c", "in", "self", ".", "_collections", ":", "_c", ".", "draw", "(", "renderer", ")", "def", "insert_rasterized_contour_plot", "(", "c", ")", ":", "collections", "=", "c", ".", "collections", "for", "_c", "in", "collections", ":", "_c", ".", "remove", "(", ")", "cc", "=", "ListCollection", "(", "collections", ",", "rasterized", "=", "True", ")", "ax", "=", "pl", ".", "gca", "(", ")", "ax", ".", "add_artist", "(", "cc", ")", "return", "cc", "cmapMIX", "=", "matplotlib", ".", "colors", ".", "ListedColormap", "(", "[", "'w'", ",", "'#8B8386'", "]", ")", "# rose grey", "if", "CBM", ":", "cmapCBM", "=", "matplotlib", ".", "colors", ".", "ListedColormap", "(", "[", "'w'", ",", "'g'", "]", ")", "# green", "cmapB1", "=", "pyl", ".", "cm", ".", "get_cmap", "(", "'Blues'", ")", "cmapB2", "=", "pl", ".", "cm", ".", "get_cmap", "(", "'Reds'", ")", "ylims1", "=", "[", "0.", ",", "0.", "]", "ylims1", "[", "0", "]", "=", "ylims", "[", "0", "]", "ylims1", "[", "1", "]", "=", "ylims", "[", "1", "]", "if", "ylims", "==", "[", "0.", ",", "0.", "]", ":", "ylims", "[", "0", "]", "=", "0.", "ylims", "[", "1", "]", "=", "mup", "#print(\"Setting ylims[1] to mup=\"+str(mup))", "if", "ylims", "[", "0", "]", "!=", "0.", ":", "ylab", "=", "'$(\\mathrm{Mass }$ - '", "+", "str", "(", "ylims", "[", "0", "]", ")", "if", "yscale", "!=", "'1.'", ":", "ylab", "+=", "') / '", "+", "yscale", "+", "'", "o", "dot", "$", "'", "else", ":", "ylab", "+", "=", "'", "o", "dot", "$", "'", "ax", ".", "set_ylabel", "(", "ylab", ")", "y", "=", "y", "-", "ylims", "[", "0", "]", "y", "=", "y", "*", "float", "(", "yscale", ")", "# SJONES tweak", "ylims", "[", "0", "]", "=", "y", "[", "0", "]", "ylims", "[", "1", "]", "=", "y", "[", "-", "1", "]", "print", "(", "'plotting contours'", ")", "CMIX", "=", "ax", ".", "contourf", "(", "xxx", "[", ":", ":", "dx", "]", ",", "y", ",", "Z", ",", "cmap", "=", "cmapMIX", ",", "alpha", "=", "0.6", ",", "levels", "=", "[", "0.5", ",", "1.5", "]", ")", "#CMIX = ax.pcolor(xxx[::dx],y,Z, cmap=cmapMIX,alpha=0.6,vmin=0.5,vmax=1.5)", "if", "rasterise", "==", "True", ":", "insert_rasterized_contour_plot", "(", "CMIX", ")", "if", "outlines", "==", "True", ":", "CMIX_outlines", "=", "ax", ".", "contour", "(", "xxx", "[", ":", ":", "dx", "]", ",", "y", ",", "Z", ",", "cmap", "=", "cmapMIX", ")", "if", "rasterise", "==", "True", ":", "insert_rasterized_contour_plot", "(", "CMIX_outlines", ")", "if", "CBM", ":", "CCBM", "=", "ax", ".", "contourf", "(", "xxx", "[", ":", ":", "dx", "]", ",", "y", ",", "Zcbm", ",", "cmap", "=", "cmapCBM", ",", "alpha", "=", "0.6", ",", "levels", "=", "[", "0.5", ",", "1.5", "]", ")", "if", "rasterise", "==", "True", ":", "insert_rasterized_contour_plot", "(", "CCBM", ")", "if", "outlines", "==", "True", ":", "CCBM_outlines", "=", "ax", ".", "contour", "(", "xxx", "[", ":", ":", "dx", "]", ",", "y", ",", "Zcbm", ",", "cmap", "=", "cmapCBM", ")", "if", "rasterise", "==", "True", ":", "insert_rasterized_contour_plot", "(", "CCBM_outlines", ")", "if", "engenstyle", "==", "'full'", "and", "engenPlus", "==", "True", ":", "if", "engenlevels", "!=", "None", ":", "CBURN1", "=", "ax", ".", "contourf", "(", "xxx", "[", ":", ":", "dx", "]", ",", "y", ",", "B1", ",", "cmap", "=", "cmapB1", ",", "alpha", "=", "0.5", ",", "locator", "=", "matplotlib", ".", "ticker", ".", "LogLocator", "(", ")", ",", "levels", "=", "engenlevels", ")", "if", "outlines", ":", "CB1_outlines", "=", "ax", ".", "contour", "(", "xxx", "[", ":", ":", "dx", "]", ",", "y", ",", "B1", ",", "cmap", "=", "cmapB1", ",", "alpha", "=", "0.7", ",", "locator", "=", "matplotlib", ".", "ticker", ".", "LogLocator", "(", ")", ",", "levels", "=", "engenlevels", ")", "else", ":", "CBURN1", "=", "ax", ".", "contourf", "(", "xxx", "[", ":", ":", "dx", "]", ",", "y", ",", "B1", ",", "cmap", "=", "cmapB1", ",", "alpha", "=", "0.5", ",", "locator", "=", "matplotlib", ".", "ticker", ".", "LogLocator", "(", ")", ")", "if", "outlines", ":", "CB1_outlines", "=", "ax", ".", "contour", "(", "xxx", "[", ":", ":", "dx", "]", ",", "y", ",", "B1", ",", "cmap", "=", "cmapB1", ",", "alpha", "=", "0.7", ",", "locator", "=", "matplotlib", ".", "ticker", ".", "LogLocator", "(", ")", ")", "CBARBURN1", "=", "pyl", ".", "colorbar", "(", "CBURN1", ")", "CBARBURN1", ".", "set_label", "(", "'$|\\epsilon_\\mathrm{nuc}-\\epsilon_{\\\\nu}| \\; (\\mathrm{erg\\,g}^{-1}\\mathrm{\\,s}^{-1})$'", ",", "fontsize", "=", "fsize", ")", "if", "rasterise", "==", "True", ":", "insert_rasterized_contour_plot", "(", "CBURN1", ")", "if", "outlines", ":", "insert_rasterized_contour_plot", "(", "CB1_outlines", ")", "if", "engenstyle", "==", "'full'", "and", "engenMinus", "==", "True", ":", "CBURN2", "=", "ax", ".", "contourf", "(", "xxx", "[", ":", ":", "dx", "]", ",", "y", ",", "B2", ",", "cmap", "=", "cmapB2", ",", "alpha", "=", "0.5", ",", "locator", "=", "matplotlib", ".", "ticker", ".", "LogLocator", "(", ")", ")", "if", "outlines", ":", "CBURN2_outlines", "=", "ax", ".", "contour", "(", "xxx", "[", ":", ":", "dx", "]", ",", "y", ",", "B2", ",", "cmap", "=", "cmapB2", ",", "alpha", "=", "0.7", ",", "locator", "=", "matplotlib", ".", "ticker", ".", "LogLocator", "(", ")", ")", "CBARBURN2", "=", "pl", ".", "colorbar", "(", "CBURN2", ")", "if", "engenPlus", "==", "False", ":", "CBARBURN2", ".", "set_label", "(", "'$|\\epsilon_\\mathrm{nuc}-\\epsilon_{\\\\nu}| \\; (\\mathrm{erg\\,g}^{-1}\\mathrm{\\,s}^{-1})$'", ",", "fontsize", "=", "fsize", ")", "if", "rasterise", "==", "True", ":", "insert_rasterized_contour_plot", "(", "CBURN2", ")", "if", "outlines", ":", "insert_rasterized_contour_plot", "(", "CB2_outlines", ")", "if", "engenstyle", "==", "'twozone'", "and", "(", "engenPlus", "==", "True", "or", "engenMinus", "==", "True", ")", ":", "ax", ".", "contourf", "(", "xxx", "[", ":", ":", "dx", "]", ",", "y", ",", "V", ",", "cmap", "=", "cmapB1", ",", "alpha", "=", "0.5", ")", "print", "(", "'plotting patches'", ")", "mtot", "=", "self", ".", "get", "(", "'star_mass'", ")", "[", "modstart", ":", "modstop", "]", "[", ":", ":", "dx", "]", "mtot1", "=", "(", "mtot", "-", "ylims1", "[", "0", "]", ")", "*", "float", "(", "yscale", ")", "ax", ".", "plot", "(", "xxx", "[", ":", ":", "dx", "]", ",", "mtot1", ",", "'k-'", ")", "if", "boundaries", "==", "True", ":", "print", "(", "'plotting abund boundaries'", ")", "try", ":", "bound", "=", "self", ".", "get", "(", "'h1_boundary_mass'", ")", "[", "modstart", ":", "modstop", "]", "bound1", "=", "(", "bound", "-", "ylims1", "[", "0", "]", ")", "*", "float", "(", "yscale", ")", "ax", ".", "plot", "(", "xxx", ",", "bound1", ",", "label", "=", "'H boundary'", ",", "linestyle", "=", "'-'", ")", "bound", "=", "self", ".", "get", "(", "'he4_boundary_mass'", ")", "[", "modstart", ":", "modstop", "]", "bound1", "=", "(", "bound", "-", "ylims1", "[", "0", "]", ")", "*", "float", "(", "yscale", ")", "ax", ".", "plot", "(", "xxx", ",", "bound1", ",", "label", "=", "'He boundary'", ",", "linestyle", "=", "'--'", ")", "bound", "=", "self", ".", "get", "(", "'c12_boundary_mass'", ")", "[", "modstart", ":", "modstop", "]", "bound1", "=", "(", "bound", "-", "ylims1", "[", "0", "]", ")", "*", "float", "(", "yscale", ")", "ax", ".", "plot", "(", "xxx", ",", "bound1", ",", "label", "=", "'C boundary'", ",", "linestyle", "=", "'-.'", ")", "except", ":", "try", ":", "bound", "=", "self", ".", "get", "(", "'he_core_mass'", ")", "[", "modstart", ":", "modstop", "]", "bound1", "=", "(", "bound", "-", "ylims1", "[", "0", "]", ")", "*", "float", "(", "yscale", ")", "ax", ".", "plot", "(", "xxx", ",", "bound1", ",", "label", "=", "'H boundary'", ",", "linestyle", "=", "'-'", ")", "bound", "=", "self", ".", "get", "(", "'c_core_mass'", ")", "[", "modstart", ":", "modstop", "]", "-", "ylims", "[", "0", "]", "bound1", "=", "(", "bound", "-", "ylims1", "[", "0", "]", ")", "*", "float", "(", "yscale", ")", "ax", ".", "plot", "(", "xxx", ",", "bound1", ",", "label", "=", "'He boundary'", ",", "linestyle", "=", "'--'", ")", "bound", "=", "self", ".", "get", "(", "'o_core_mass'", ")", "[", "modstart", ":", "modstop", "]", "-", "ylims", "[", "0", "]", "bound1", "=", "(", "bound", "-", "ylims1", "[", "0", "]", ")", "*", "float", "(", "yscale", ")", "ax", ".", "plot", "(", "xxx", ",", "bound1", ",", "label", "=", "'C boundary'", ",", "linestyle", "=", "'-.'", ")", "bound", "=", "self", ".", "get", "(", "'si_core_mass'", ")", "[", "modstart", ":", "modstop", "]", "-", "ylims", "[", "0", "]", "bound1", "=", "(", "bound", "-", "ylims1", "[", "0", "]", ")", "*", "float", "(", "yscale", ")", "ax", ".", "plot", "(", "xxx", ",", "bound1", ",", "label", "=", "'C boundary'", ",", "linestyle", "=", "'-.'", ")", "bound", "=", "self", ".", "get", "(", "'fe_core_mass'", ")", "[", "modstart", ":", "modstop", "]", "-", "ylims", "[", "0", "]", "bound1", "=", "(", "bound", "-", "ylims1", "[", "0", "]", ")", "*", "float", "(", "yscale", ")", "ax", ".", "plot", "(", "xxx", ",", "bound1", ",", "label", "=", "'C boundary'", ",", "linestyle", "=", "'-.'", ")", "except", ":", "# print 'problem to plot boundaries for this plot'", "pass", "ax", ".", "axis", "(", "[", "xlims", "[", "0", "]", ",", "xlims", "[", "1", "]", ",", "ylims", "[", "0", "]", ",", "ylims", "[", "1", "]", "]", ")", "if", "plot_radius", "==", "True", ":", "ax2", "=", "pyl", ".", "twinx", "(", ")", "ax2", ".", "plot", "(", "xxx", ",", "np", ".", "log10", "(", "self", ".", "get", "(", "'he4_boundary_radius'", ")", "[", "modstart", ":", "modstop", "]", ")", ",", "label", "=", "'He boundary radius'", ",", "color", "=", "'k'", ",", "linewidth", "=", "1.", ",", "linestyle", "=", "'-.'", ")", "ax2", ".", "plot", "(", "xxx", ",", "self", ".", "get", "(", "'log_R'", ")", "[", "modstart", ":", "modstop", "]", ",", "label", "=", "'radius'", ",", "color", "=", "'k'", ",", "linewidth", "=", "1.", ",", "linestyle", "=", "'-.'", ")", "ax2", ".", "set_ylabel", "(", "'log(radius)'", ")", "if", "rad_lines", "==", "True", ":", "ax2", "=", "pyl", ".", "twinx", "(", ")", "for", "i", "in", "range", "(", "len", "(", "masses", ")", ")", ":", "ax2", ".", "plot", "(", "modno", ",", "np", ".", "log10", "(", "rads", "[", "i", "]", ")", ",", "color", "=", "'k'", ")", "if", "outfile", "[", "-", "3", ":", "]", "==", "'png'", ":", "fig", ".", "savefig", "(", "outfile", ",", "dpi", "=", "300", ")", "elif", "outfile", "[", "-", "3", ":", "]", "==", "'eps'", ":", "fig", ".", "savefig", "(", "outfile", ",", "format", "=", "'eps'", ")", "elif", "outfile", "[", "-", "3", ":", "]", "==", "'pdf'", ":", "fig", ".", "savefig", "(", "outfile", ",", "format", "=", "'pdf'", ")", "if", "showfig", "==", "True", ":", "pyl", ".", "show", "(", ")" ]

[ "This", "function", "creates", "a", "Kippenhahn", "plot", "with", "energy", "flux", "using", "contours", "." ]

[ "def", "on_timer", "(", "self", ",", "event", ")", ":", "state", "=", "self", ".", "state", "self", ".", "loopStartTime", "=", "time", ".", "time", "(", ")", "if", "state", ".", "close_event", ".", "wait", "(", "0.001", ")", ":", "self", ".", "timer", ".", "Stop", "(", ")", "self", ".", "Destroy", "(", ")", "return", "# Check for resizing", "self", ".", "checkReszie", "(", ")", "if", "self", ".", "resized", ":", "self", ".", "on_idle", "(", "0", ")", "# Get attitude information", "while", "state", ".", "child_pipe_recv", ".", "poll", "(", ")", ":", "objList", "=", "state", ".", "child_pipe_recv", ".", "recv", "(", ")", "for", "obj", "in", "objList", ":", "self", ".", "calcFontScaling", "(", ")", "if", "isinstance", "(", "obj", ",", "Attitude", ")", ":", "self", ".", "oldRoll", "=", "self", ".", "roll", "self", ".", "pitch", "=", "obj", ".", "pitch", "*", "180", "/", "math", ".", "pi", "self", ".", "roll", "=", "obj", ".", "roll", "*", "180", "/", "math", ".", "pi", "self", ".", "yaw", "=", "obj", ".", "yaw", "*", "180", "/", "math", ".", "pi", "# Update Roll, Pitch, Yaw Text Text", "self", ".", "updateRPYText", "(", ")", "# Recalculate Horizon Polygons", "self", ".", "calcHorizonPoints", "(", ")", "# Update Pitch Markers", "self", ".", "adjustPitchmarkers", "(", ")", "elif", "isinstance", "(", "obj", ",", "VFR_HUD", ")", ":", "self", ".", "heading", "=", "obj", ".", "heading", "self", ".", "airspeed", "=", "obj", ".", "airspeed", "self", ".", "climbRate", "=", "obj", ".", "climbRate", "# Update Airpseed, Altitude, Climb Rate Locations", "self", ".", "updateAARText", "(", ")", "# Update Heading North Pointer", "self", ".", "adjustHeadingPointer", "(", ")", "self", ".", "adjustNorthPointer", "(", ")", "elif", "isinstance", "(", "obj", ",", "Global_Position_INT", ")", ":", "self", ".", "relAlt", "=", "obj", ".", "relAlt", "self", ".", "relAltTime", "=", "obj", ".", "curTime", "# Update Airpseed, Altitude, Climb Rate Locations", "self", ".", "updateAARText", "(", ")", "# Update Altitude History", "self", ".", "updateAltHistory", "(", ")", "elif", "isinstance", "(", "obj", ",", "BatteryInfo", ")", ":", "self", ".", "voltage", "=", "obj", ".", "voltage", "self", ".", "current", "=", "obj", ".", "current", "self", ".", "batRemain", "=", "obj", ".", "batRemain", "# Update Battery Bar", "self", ".", "updateBatteryBar", "(", ")", "elif", "isinstance", "(", "obj", ",", "FlightState", ")", ":", "self", ".", "mode", "=", "obj", ".", "mode", "self", ".", "armed", "=", "obj", ".", "armState", "# Update Mode and Arm State Text", "self", ".", "updateStateText", "(", ")", "elif", "isinstance", "(", "obj", ",", "WaypointInfo", ")", ":", "self", ".", "currentWP", "=", "obj", ".", "current", "self", ".", "finalWP", "=", "obj", ".", "final", "self", ".", "wpDist", "=", "obj", ".", "currentDist", "self", ".", "nextWPTime", "=", "obj", ".", "nextWPTime", "if", "obj", ".", "wpBearing", "<", "0.0", ":", "self", ".", "wpBearing", "=", "obj", ".", "wpBearing", "+", "360", "else", ":", "self", ".", "wpBearing", "=", "obj", ".", "wpBearing", "# Update waypoint text", "self", ".", "updateWPText", "(", ")", "# Adjust Waypoint Pointer", "self", ".", "adjustWPPointer", "(", ")", "elif", "isinstance", "(", "obj", ",", "FPS", ")", ":", "# Update fps target", "self", ".", "fps", "=", "obj", ".", "fps", "# Quit Drawing if too early", "if", "(", "time", ".", "time", "(", ")", ">", "self", ".", "nextTime", ")", ":", "# Update Matplotlib Plot", "self", ".", "canvas", ".", "draw", "(", ")", "self", ".", "canvas", ".", "Refresh", "(", ")", "self", ".", "Refresh", "(", ")", "self", ".", "Update", "(", ")", "# Calculate next frame time", "if", "(", "self", ".", "fps", ">", "0", ")", ":", "fpsTime", "=", "1", "/", "self", ".", "fps", "self", ".", "nextTime", "=", "fpsTime", "+", "self", ".", "loopStartTime", "else", ":", "self", ".", "nextTime", "=", "time", ".", "time", "(", ")" ]

[ "Main", "Loop", "." ]

[ "def", "create_checksum_object_from_iterator", "(", "itr", ",", "algorithm", "=", "d1_common", ".", "const", ".", "DEFAULT_CHECKSUM_ALGORITHM", ")", ":", "checksum_str", "=", "calculate_checksum_on_iterator", "(", "itr", ",", "algorithm", ")", "checksum_pyxb", "=", "d1_common", ".", "types", ".", "dataoneTypes", ".", "checksum", "(", "checksum_str", ")", "checksum_pyxb", ".", "algorithm", "=", "algorithm", "return", "checksum_pyxb" ]

[ "Calculate", "the", "checksum", "of", "an", "iterator", "." ]

[ "def", "findall", "(", "dir", "=", "os", ".", "curdir", ")", ":", "all_files", "=", "[", "]", "for", "base", ",", "dirs", ",", "files", "in", "os", ".", "walk", "(", "dir", ",", "followlinks", "=", "True", ")", ":", "if", "base", "==", "os", ".", "curdir", "or", "base", ".", "startswith", "(", "os", ".", "curdir", "+", "os", ".", "sep", ")", ":", "base", "=", "base", "[", "2", ":", "]", "if", "base", ":", "files", "=", "[", "os", ".", "path", ".", "join", "(", "base", ",", "f", ")", "for", "f", "in", "files", "]", "all_files", ".", "extend", "(", "filter", "(", "os", ".", "path", ".", "isfile", ",", "files", ")", ")", "return", "all_files" ]

[ "Find", "all", "files", "under", "dir", "and", "return", "the", "list", "of", "full", "filenames", "(", "relative", "to", "dir", ")", "." ]

[ "def", "nic_add", "(", "self", ",", "container", ",", "nic", ")", ":", "args", "=", "{", "'container'", ":", "container", ",", "'nic'", ":", "nic", "}", "self", ".", "_nic_add", ".", "check", "(", "args", ")", "return", "self", ".", "_client", ".", "json", "(", "'corex.nic-add'", ",", "args", ")" ]

[ "Hot", "plug", "a", "nic", "into", "a", "container" ]

[ "def", "_get_contexts_for_squash", "(", "self", ",", "batch_signature", ")", ":", "batch", "=", "self", ".", "_batches_by_id", "[", "batch_signature", "]", ".", "batch", "index", "=", "self", ".", "_batches", ".", "index", "(", "batch", ")", "contexts", "=", "[", "]", "txns_added_predecessors", "=", "[", "]", "for", "b", "in", "self", ".", "_batches", "[", "index", ":", ":", "-", "1", "]", ":", "batch_is_valid", "=", "True", "contexts_from_batch", "=", "[", "]", "for", "txn", "in", "b", ".", "transactions", "[", ":", ":", "-", "1", "]", ":", "result", "=", "self", ".", "_txn_results", "[", "txn", ".", "header_signature", "]", "if", "not", "result", ".", "is_valid", ":", "batch_is_valid", "=", "False", "break", "else", ":", "txn_id", "=", "txn", ".", "header_signature", "if", "txn_id", "not", "in", "txns_added_predecessors", ":", "txns_added_predecessors", ".", "append", "(", "self", ".", "_txn_predecessors", "[", "txn_id", "]", ")", "contexts_from_batch", ".", "append", "(", "result", ".", "context_id", ")", "if", "batch_is_valid", ":", "contexts", ".", "extend", "(", "contexts_from_batch", ")", "return", "contexts" ]

[ "Starting", "with", "the", "batch", "referenced", "by", "batch_signature", "iterate", "back", "through", "the", "batches", "and", "for", "each", "valid", "batch", "collect", "the", "context_id", ".", "At", "the", "end", "remove", "contexts", "for", "txns", "that", "are", "other", "txn", "s", "predecessors", "." ]

[ "def", "BuildServiceStub", "(", "self", ",", "cls", ")", ":", "def", "_ServiceStubInit", "(", "stub", ",", "rpc_channel", ")", ":", "stub", ".", "rpc_channel", "=", "rpc_channel", "self", ".", "cls", "=", "cls", "cls", ".", "__init__", "=", "_ServiceStubInit", "for", "method", "in", "self", ".", "descriptor", ".", "methods", ":", "setattr", "(", "cls", ",", "method", ".", "name", ",", "self", ".", "_GenerateStubMethod", "(", "method", ")", ")" ]

[ "Constructs", "the", "stub", "class", "." ]

[ "def", "display", "(", "obj", ",", "raw_output", "=", "False", ",", "*", "*", "kwargs", ")", ":", "if", "not", "Store", ".", "loaded_backends", "(", ")", "and", "isinstance", "(", "obj", ",", "Dimensioned", ")", ":", "raise", "RuntimeError", "(", "'To use display on a HoloViews object ensure '", "'a backend is loaded using the holoviews '", "'extension.'", ")", "raw", "=", "True", "if", "isinstance", "(", "obj", ",", "GridSpace", ")", ":", "with", "option_state", "(", "obj", ")", ":", "output", "=", "grid_display", "(", "obj", ")", "elif", "isinstance", "(", "obj", ",", "(", "CompositeOverlay", ",", "ViewableElement", ")", ")", ":", "with", "option_state", "(", "obj", ")", ":", "output", "=", "element_display", "(", "obj", ")", "elif", "isinstance", "(", "obj", ",", "(", "Layout", ",", "NdLayout", ",", "AdjointLayout", ")", ")", ":", "with", "option_state", "(", "obj", ")", ":", "output", "=", "layout_display", "(", "obj", ")", "elif", "isinstance", "(", "obj", ",", "(", "HoloMap", ",", "DynamicMap", ")", ")", ":", "with", "option_state", "(", "obj", ")", ":", "output", "=", "map_display", "(", "obj", ")", "elif", "isinstance", "(", "obj", ",", "Plot", ")", ":", "output", "=", "render", "(", "obj", ")", "else", ":", "output", "=", "obj", "raw", "=", "kwargs", ".", "pop", "(", "'raw'", ",", "False", ")", "if", "raw_output", ":", "return", "output", "elif", "isinstance", "(", "output", ",", "tuple", ")", ":", "data", ",", "metadata", "=", "output", "else", ":", "data", ",", "metadata", "=", "output", ",", "{", "}", "return", "IPython", ".", "display", ".", "display", "(", "data", ",", "raw", "=", "raw", ",", "metadata", "=", "metadata", ",", "*", "*", "kwargs", ")" ]

[ "Renders", "any", "HoloViews", "object", "to", "HTML", "and", "displays", "it", "using", "the", "IPython", "display", "function", ".", "If", "raw", "is", "enabled", "the", "raw", "HTML", "is", "returned", "instead", "of", "displaying", "it", "directly", "." ]

[ "def", "create_exception_for_response", "(", "cls", ",", "response_code", ",", "messages", ",", "response_id", ")", ":", "error_message", "=", "cls", ".", "_generate_message_error", "(", "response_code", ",", "messages", ",", "response_id", ")", "if", "response_code", "==", "cls", ".", "_HTTP_RESPONSE_CODE_BAD_REQUEST", ":", "return", "BadRequestException", "(", "error_message", ",", "response_code", ",", "response_id", ")", "if", "response_code", "==", "cls", ".", "_HTTP_RESPONSE_CODE_UNAUTHORIZED", ":", "return", "UnauthorizedException", "(", "error_message", ",", "response_code", ",", "response_id", ")", "if", "response_code", "==", "cls", ".", "_HTTP_RESPONSE_CODE_FORBIDDEN", ":", "return", "ForbiddenException", "(", "error_message", ",", "response_code", ",", "response_id", ")", "if", "response_code", "==", "cls", ".", "_HTTP_RESPONSE_CODE_NOT_FOUND", ":", "return", "NotFoundException", "(", "error_message", ",", "response_code", ",", "response_id", ")", "if", "response_code", "==", "cls", ".", "_HTTP_RESPONSE_CODE_METHOD_NOT_ALLOWED", ":", "return", "MethodNotAllowedException", "(", "error_message", ",", "response_code", ",", "response_id", ")", "if", "response_code", "==", "cls", ".", "_HTTP_RESPONSE_CODE_TOO_MANY_REQUESTS", ":", "return", "TooManyRequestsException", "(", "error_message", ",", "response_code", ",", "response_id", ")", "if", "response_code", "==", "cls", ".", "_HTTP_RESPONSE_CODE_INTERNAL_SERVER_ERROR", ":", "return", "PleaseContactBunqException", "(", "error_message", ",", "response_code", ",", "response_id", ")", "return", "UnknownApiErrorException", "(", "error_message", ",", "response_code", ",", "response_id", ")" ]

[ ":", "type", "response_code", ":", "int", ":", "type", "messages", ":", "list", "[", "str", "]", ":", "type", "response_id", ":", "str" ]

[ "def", "_validate", "(", "self", ",", "obj", ")", ":", "report", "=", "ValidationReport", "(", ")", "if", "not", "self", ".", "validator", ".", "is_valid", "(", "obj", ")", ":", "for", "v", "in", "self", ".", "validator", ".", "iter_errors", "(", "obj", ")", ":", "report", ".", "add_error", "(", "\"[%s] %s\"", "%", "(", "'.'", ".", "join", "(", "str", "(", "vv", ")", "for", "vv", "in", "v", ".", "path", ")", ",", "v", ".", "message", ")", ")", "return", "report" ]

[ "Do", "the", "actual", "validation" ]

[ "def", "isemhash_unbottleneck", "(", "x", ",", "hidden_size", ",", "isemhash_filter_size_multiplier", "=", "1.0", ")", ":", "filter_size", "=", "int", "(", "hidden_size", "*", "isemhash_filter_size_multiplier", ")", "x", "=", "0.5", "*", "(", "x", "-", "1.0", ")", "# Move from [-1, 1] to [0, 1].", "with", "tf", ".", "variable_scope", "(", "\"isemhash_unbottleneck\"", ")", ":", "h1a", "=", "tf", ".", "layers", ".", "dense", "(", "x", ",", "filter_size", ",", "name", "=", "\"hidden1a\"", ")", "h1b", "=", "tf", ".", "layers", ".", "dense", "(", "1.0", "-", "x", ",", "filter_size", ",", "name", "=", "\"hidden1b\"", ")", "h2", "=", "tf", ".", "layers", ".", "dense", "(", "tf", ".", "nn", ".", "relu", "(", "h1a", "+", "h1b", ")", ",", "filter_size", ",", "name", "=", "\"hidden2\"", ")", "return", "tf", ".", "layers", ".", "dense", "(", "tf", ".", "nn", ".", "relu", "(", "h2", ")", ",", "hidden_size", ",", "name", "=", "\"final\"", ")" ]

[ "Improved", "semantic", "hashing", "un", "-", "bottleneck", "." ]

[ "def", "search_subscriptions", "(", "self", ",", "*", "*", "kwargs", ")", ":", "params", "=", "[", "(", "key", ",", "kwargs", "[", "key", "]", ")", "for", "key", "in", "sorted", "(", "kwargs", ".", "keys", "(", ")", ")", "]", "url", "=", "\"/notification/v1/subscription?{}\"", ".", "format", "(", "urlencode", "(", "params", ",", "doseq", "=", "True", ")", ")", "response", "=", "NWS_DAO", "(", ")", ".", "getURL", "(", "url", ",", "self", ".", "_read_headers", ")", "if", "response", ".", "status", "!=", "200", ":", "raise", "DataFailureException", "(", "url", ",", "response", ".", "status", ",", "response", ".", "data", ")", "data", "=", "json", ".", "loads", "(", "response", ".", "data", ")", "subscriptions", "=", "[", "]", "for", "datum", "in", "data", ".", "get", "(", "\"Subscriptions\"", ",", "[", "]", ")", ":", "subscriptions", ".", "append", "(", "self", ".", "_subscription_from_json", "(", "datum", ")", ")", "return", "subscriptions" ]

[ "Search", "for", "all", "subscriptions", "by", "parameters" ]

[ "def", "setsweeps", "(", "self", ")", ":", "for", "sweep", "in", "range", "(", "self", ".", "sweeps", ")", ":", "self", ".", "setsweep", "(", "sweep", ")", "yield", "self", ".", "sweep" ]

[ "iterate", "over", "every", "sweep" ]

[ "def", "ConvertToWireFormat", "(", "self", ",", "value", ")", ":", "output", "=", "_SerializeEntries", "(", "_GetOrderedEntries", "(", "value", ".", "GetRawData", "(", ")", ")", ")", "return", "(", "self", ".", "encoded_tag", ",", "VarintEncode", "(", "len", "(", "output", ")", ")", ",", "output", ")" ]

[ "Encode", "the", "nested", "protobuf", "into", "wire", "format", "." ]

[ "def", "fit", "(", "self", ",", "xy", "=", "False", ",", "*", "*", "kwargs", ")", ":", "kwargs", ".", "setdefault", "(", "'s'", ",", "self", ".", "tpr", ")", "kwargs", ".", "setdefault", "(", "'n'", ",", "self", ".", "ndx", ")", "kwargs", "[", "'f'", "]", "=", "self", ".", "xtc", "force", "=", "kwargs", ".", "pop", "(", "'force'", ",", "self", ".", "force", ")", "if", "xy", ":", "fitmode", "=", "'rotxy+transxy'", "kwargs", ".", "pop", "(", "'fit'", ",", "None", ")", "infix_default", "=", "'_fitxy'", "else", ":", "fitmode", "=", "kwargs", ".", "pop", "(", "'fit'", ",", "'rot+trans'", ")", "# user can use 'progressive', too", "infix_default", "=", "'_fit'", "dt", "=", "kwargs", ".", "get", "(", "'dt'", ")", "if", "dt", ":", "infix_default", "+=", "'_dt{0:d}ps'", ".", "format", "(", "int", "(", "dt", ")", ")", "# dt in ps", "kwargs", ".", "setdefault", "(", "'o'", ",", "self", ".", "outfile", "(", "self", ".", "infix_filename", "(", "None", ",", "self", ".", "xtc", ",", "infix_default", ",", "'xtc'", ")", ")", ")", "fitgroup", "=", "kwargs", ".", "pop", "(", "'fitgroup'", ",", "'backbone'", ")", "kwargs", ".", "setdefault", "(", "'input'", ",", "[", "fitgroup", ",", "\"system\"", "]", ")", "if", "kwargs", ".", "get", "(", "'center'", ",", "False", ")", ":", "logger", ".", "warn", "(", "\"Transformer.fit(): center=%(center)r used: centering should not be combined with fitting.\"", ",", "kwargs", ")", "if", "len", "(", "kwargs", "[", "'inputs'", "]", ")", "!=", "3", ":", "logger", ".", "error", "(", "\"If you insist on centering you must provide three groups in the 'input' kwarg: (center, fit, output)\"", ")", "raise", "ValuError", "(", "\"Insufficient index groups for centering,fitting,output\"", ")", "logger", ".", "info", "(", "\"Fitting trajectory %r to with xy=%r...\"", ",", "kwargs", "[", "'f'", "]", ",", "xy", ")", "logger", ".", "info", "(", "\"Fitting on index group %(fitgroup)r\"", ",", "vars", "(", ")", ")", "with", "utilities", ".", "in_dir", "(", "self", ".", "dirname", ")", ":", "if", "self", ".", "check_file_exists", "(", "kwargs", "[", "'o'", "]", ",", "resolve", "=", "\"indicate\"", ",", "force", "=", "force", ")", ":", "logger", ".", "warn", "(", "\"File %r exists; force regenerating it with force=True.\"", ",", "kwargs", "[", "'o'", "]", ")", "else", ":", "gromacs", ".", "trjconv", "(", "fit", "=", "fitmode", ",", "*", "*", "kwargs", ")", "logger", ".", "info", "(", "\"Fitted trajectory (fitmode=%s): %r.\"", ",", "fitmode", ",", "kwargs", "[", "'o'", "]", ")", "return", "{", "'tpr'", ":", "self", ".", "rp", "(", "kwargs", "[", "'s'", "]", ")", ",", "'xtc'", ":", "self", ".", "rp", "(", "kwargs", "[", "'o'", "]", ")", "}" ]

[ "Write", "xtc", "that", "is", "fitted", "to", "the", "tpr", "reference", "structure", "." ]

[ "def", "check_url", "(", "aggregate", ")", ":", "while", "True", ":", "try", ":", "aggregate", ".", "urlqueue", ".", "join", "(", "timeout", "=", "30", ")", "break", "except", "urlqueue", ".", "Timeout", ":", "# Cleanup threads every 30 seconds", "aggregate", ".", "remove_stopped_threads", "(", ")", "if", "not", "any", "(", "aggregate", ".", "get_check_threads", "(", ")", ")", ":", "break" ]

[ "Helper", "function", "waiting", "for", "URL", "queue", "." ]

[ "def", "on_completions_request", "(", "self", ",", "py_db", ",", "request", ")", ":", "arguments", "=", "request", ".", "arguments", "# : :type arguments: CompletionsArguments", "seq", "=", "request", ".", "seq", "text", "=", "arguments", ".", "text", "frame_id", "=", "arguments", ".", "frameId", "thread_id", "=", "py_db", ".", "suspended_frames_manager", ".", "get_thread_id_for_variable_reference", "(", "frame_id", ")", "if", "thread_id", "is", "None", ":", "body", "=", "CompletionsResponseBody", "(", "[", "]", ")", "variables_response", "=", "pydevd_base_schema", ".", "build_response", "(", "request", ",", "kwargs", "=", "{", "'body'", ":", "body", ",", "'success'", ":", "False", ",", "'message'", ":", "'Thread to get completions seems to have resumed already.'", "}", ")", "return", "NetCommand", "(", "CMD_RETURN", ",", "0", ",", "variables_response", ",", "is_json", "=", "True", ")", "# Note: line and column are 1-based (convert to 0-based for pydevd).", "column", "=", "arguments", ".", "column", "-", "1", "if", "arguments", ".", "line", "is", "None", ":", "# line is optional", "line", "=", "-", "1", "else", ":", "line", "=", "arguments", ".", "line", "-", "1", "self", ".", "api", ".", "request_completions", "(", "py_db", ",", "seq", ",", "thread_id", ",", "frame_id", ",", "text", ",", "line", "=", "line", ",", "column", "=", "column", ")" ]

[ ":", "param", "CompletionsRequest", "request", ":" ]

[ "def", "check_ips", "(", "self", ",", "addrs", ")", ":", "tasks", "=", "[", "]", "for", "addr", "in", "addrs", ":", "tasks", ".", "append", "(", "self", ".", "_check_ip", "(", "addr", ")", ")", "return", "self", ".", "_loop", ".", "run_until_complete", "(", "asyncio", ".", "gather", "(", "*", "tasks", ")", ")" ]

[ "sync", "check", "multiple", "ips" ]

[ "def", "isatty", "(", "file", ")", ":", "if", "(", "multiprocessing", ".", "current_process", "(", ")", ".", "name", "!=", "'MainProcess'", "or", "threading", ".", "current_thread", "(", ")", ".", "getName", "(", ")", "!=", "'MainThread'", ")", ":", "return", "False", "if", "hasattr", "(", "file", ",", "'isatty'", ")", ":", "return", "file", ".", "isatty", "(", ")", "elif", "(", "OutStream", "is", "not", "None", "and", "isinstance", "(", "file", ",", "(", "OutStream", ",", "IPythonIOStream", ")", ")", "and", "(", "(", "hasattr", "(", "file", ",", "'name'", ")", "and", "file", ".", "name", "==", "'stdout'", ")", "or", "(", "hasattr", "(", "file", ",", "'stream'", ")", "and", "isinstance", "(", "file", ".", "stream", ",", "PyreadlineConsole", ")", ")", ")", ")", ":", "# File is an IPython OutStream or IOStream and", "# File name is 'stdout' or", "# File wraps a Console", "return", "True", "return", "False" ]

[ "Returns", "True", "if", "file", "is", "a", "tty", "." ]

[ "def", "set_permissions_all", "(", "self", ",", "replace", "=", "False", ")", ":", "bucket", "=", "self", ".", "_get_bucket", "(", ")", "for", "key", "in", "bucket", ":", "self", ".", "set_permissions", "(", "key", ",", "replace", ")" ]

[ "Sets", "the", "S3", "ACL", "grants", "for", "all", "objects", "in", "the", "Distribution", "to", "the", "appropriate", "value", "based", "on", "the", "type", "of", "Distribution", "." ]

[ "def", "dest_fpath", "(", "self", ",", "source_fpath", ":", "str", ")", "->", "str", ":", "relative_fpath", "=", "os", ".", "path", ".", "join", "(", "*", "source_fpath", ".", "split", "(", "os", ".", "sep", ")", "[", "1", ":", "]", ")", "relative_dirpath", "=", "os", ".", "path", ".", "dirname", "(", "relative_fpath", ")", "source_fname", "=", "relative_fpath", ".", "split", "(", "os", ".", "sep", ")", "[", "-", "1", "]", "base_fname", "=", "source_fname", ".", "split", "(", "'.'", ")", "[", "0", "]", "dest_fname", "=", "f'{base_fname}.json'", "return", "os", ".", "path", ".", "join", "(", "self", ".", "dest_dir", ",", "relative_dirpath", ",", "dest_fname", ")" ]

[ "Calculates", "full", "path", "for", "end", "json", "-", "api", "file", "from", "source", "file", "full", "path", "." ]

[ "def", "list", "(", "self", ",", "table", ",", "*", "*", "kparams", ")", ":", "records", "=", "self", ".", "api", ".", "list", "(", "table", ",", "*", "*", "kparams", ")", "return", "records" ]

[ "get", "a", "collection", "of", "records", "by", "table", "name", ".", "returns", "a", "collection", "of", "SnowRecord", "obj", "." ]

[ "def", "disconnect", "(", "self", ",", "callback", ")", ":", "if", "self", ".", "weak_subscribers", "is", "not", "None", ":", "with", "self", ".", "lock", ":", "index", "=", "self", ".", "_weakly_connected_index", "(", "callback", ")", "if", "index", "is", "not", "None", ":", "self", ".", "weak_subscribers", ".", "pop", "(", "index", ")", "[", "0", "]", "if", "self", ".", "hard_subscribers", "is", "not", "None", ":", "try", ":", "index", "=", "self", ".", "_hard_callbacks", "(", ")", ".", "index", "(", "callback", ")", "except", "ValueError", ":", "pass", "else", ":", "self", ".", "hard_subscribers", ".", "pop", "(", "index", ")" ]

[ "Disconnects", "the", "signal", "from", "the", "given", "function", "." ]

[ "def", "word_spans", "(", "self", ")", ":", "if", "not", "self", ".", "is_tagged", "(", "WORDS", ")", ":", "self", ".", "tokenize_words", "(", ")", "return", "self", ".", "spans", "(", "WORDS", ")" ]

[ "The", "list", "of", "spans", "representing", "words", "layer", "elements", "." ]

[ "def", "import_task", "(", "self", ",", "subject", ",", "status", ",", "*", "*", "attrs", ")", ":", "return", "Tasks", "(", "self", ".", "requester", ")", ".", "import_", "(", "self", ".", "id", ",", "subject", ",", "status", ",", "*", "*", "attrs", ")" ]

[ "Import", "a", "Task", "and", "return", "a", ":", "class", ":", "Task", "object", "." ]

[ "def", "replace_random_tokens_bow", "(", "self", ",", "n_samples", ",", "# type: int", "replacement", "=", "''", ",", "# type: str", "random_state", "=", "None", ",", "min_replace", "=", "1", ",", "# type: Union[int, float]", "max_replace", "=", "1.0", ",", "# type: Union[int, float]", ")", ":", "# type: (...) -> List[Tuple[str, int, np.ndarray]]", "if", "not", "self", ".", "vocab", ":", "nomask", "=", "np", ".", "array", "(", "[", "]", ",", "dtype", "=", "int", ")", "return", "[", "(", "''", ",", "0", ",", "nomask", ")", "]", "*", "n_samples", "min_replace", ",", "max_replace", "=", "self", ".", "_get_min_max", "(", "min_replace", ",", "max_replace", ",", "len", "(", "self", ".", "vocab", ")", ")", "rng", "=", "check_random_state", "(", "random_state", ")", "replace_sizes", "=", "rng", ".", "randint", "(", "low", "=", "min_replace", ",", "high", "=", "max_replace", "+", "1", ",", "size", "=", "n_samples", ")", "res", "=", "[", "]", "for", "num_to_replace", "in", "replace_sizes", ":", "tokens_to_replace", "=", "set", "(", "rng", ".", "choice", "(", "self", ".", "vocab", ",", "num_to_replace", ",", "replace", "=", "False", ")", ")", "idx_to_replace", "=", "[", "idx", "for", "idx", ",", "token", "in", "enumerate", "(", "self", ".", "tokens", ")", "if", "token", "in", "tokens_to_replace", "]", "mask", "=", "indices_to_bool_mask", "(", "idx_to_replace", ",", "len", "(", "self", ".", "tokens", ")", ")", "s", "=", "self", ".", "split", ".", "masked", "(", "idx_to_replace", ",", "replacement", ")", "res", ".", "append", "(", "(", "s", ".", "text", ",", "num_to_replace", ",", "mask", ")", ")", "return", "res" ]

[ "Return", "a", "list", "of", "(", "text", "replaced_words_count", "mask", ")", "tuples", "with", "n_samples", "versions", "of", "text", "with", "some", "words", "replaced", ".", "If", "a", "word", "is", "replaced", "all", "duplicate", "words", "are", "also", "replaced", "from", "the", "text", ".", "By", "default", "words", "are", "replaced", "with", "i", ".", "e", ".", "removed", "." ]

[ "def", "subclass_genesis", "(", "self", ",", "genesisclass", ")", ":", "class", "MayaGenesisWin", "(", "genesisclass", ")", ":", "\"\"\"Implementation of Genesis for maya\n \"\"\"", "def", "open_shot", "(", "self", ",", "taskfile", ")", ":", "\"\"\"Open the given taskfile\n\n :param taskfile: the taskfile for the shot\n :type taskfile: :class:`djadapter.models.TaskFile`\n :returns: True if opening was successful\n :rtype: bool\n :raises: none\n \"\"\"", "return", "self", ".", "open_file", "(", "taskfile", ")", "def", "save_shot", "(", "self", ",", "jbfile", ",", "tf", ")", ":", "\"\"\"Save the shot to the location of jbfile\n\n :param jbfile: the jbfile that can be used to query the location\n :type jbfile: :class:`jukebox.core.filesys.JB_File`\n :param tf: the taskfile that is saved\n :type tf: :class:`djadapter.models.TaskFile`\n :returns: None\n :rtype: None\n :raises: None\n \"\"\"", "self", ".", "update_scene_node", "(", "tf", ")", "self", ".", "save_file", "(", "jbfile", ")", "def", "open_asset", "(", "self", ",", "taskfile", ")", ":", "\"\"\"Open the given taskfile\n\n :param taskfile: the taskfile for the asset\n :type taskfile: :class:`djadapter.models.TaskFile`\n :returns: True if opening was successful\n :rtype: bool\n :raises: None\n \"\"\"", "return", "self", ".", "open_file", "(", "taskfile", ")", "def", "save_asset", "(", "self", ",", "jbfile", ",", "tf", ")", ":", "\"\"\"Save the asset to the location of jbfile\n\n :param jbfile: the jbfile that can be used to query the location\n :type jbfile: :class:`jukebox.core.filesys.JB_File`\n :param tf: the taskfile that is saved\n :type tf: :class:`djadapter.models.TaskFile`\n :returns: None\n :rtype: None\n :raises: NotImplementedError\n \"\"\"", "self", ".", "update_scene_node", "(", "tf", ")", "self", ".", "save_file", "(", "jbfile", ")", "def", "save_file", "(", "self", ",", "jbfile", ")", ":", "\"\"\"Physically save current scene to jbfile\\'s location\n\n :param jbfile: the jbfile that can be used to query the location\n :type jbfile: :class:`jukebox.core.filesys.JB_File`\n :returns: None\n :rtype: None\n :raises: None\n \"\"\"", "p", "=", "jbfile", ".", "get_fullpath", "(", ")", "p", "=", "os", ".", "path", ".", "expanduser", "(", "p", ")", "typ", "=", "'mayaBinary'", "if", "jbfile", ".", "get_ext", "(", ")", "==", "'ma'", ":", "typ", "=", "'mayaAscii'", "cmds", ".", "file", "(", "rename", "=", "p", ")", "cmds", ".", "file", "(", "save", "=", "True", ",", "defaultExtensions", "=", "False", ",", "type", "=", "typ", ")", "def", "open_file", "(", "self", ",", "taskfile", ")", ":", "\"\"\"Open the given jbfile in maya\n\n :param taskfile: the taskfile for the asset\n :type taskfile: :class:`djadapter.models.TaskFile`\n :returns: True if opening was successful\n :rtype: bool\n :raises: None\n \"\"\"", "r", "=", "self", ".", "check_modified", "(", ")", "if", "r", "is", "False", ":", "return", "False", "cmds", ".", "file", "(", "taskfile", ".", "path", ",", "open", "=", "True", ",", "force", "=", "True", ",", "ignoreVersion", "=", "True", ")", "return", "True", "def", "get_current_file", "(", "self", ",", ")", ":", "\"\"\"Return the taskfile that is currently open or None if no taskfile is open\n\n :returns: the open taskfile or None if no taskfile is open\n :rtype: :class:`djadapter.models.TaskFile` | None\n :raises: None\n \"\"\"", "node", "=", "jbscene", ".", "get_current_scene_node", "(", ")", "if", "not", "node", ":", "return", "tfid", "=", "cmds", ".", "getAttr", "(", "'%s.taskfile_id'", "%", "node", ")", "try", ":", "return", "djadapter", ".", "taskfiles", ".", "get", "(", "id", "=", "tfid", ")", "except", "djadapter", ".", "models", ".", "TaskFile", ".", "DoesNotExist", ":", "log", ".", "error", "(", "\"No taskfile with id %s was found. Get current scene failed. Check your jb_sceneNode \\'%s\\'.\"", "%", "(", "tfid", ",", "node", ")", ")", "return", "def", "get_scene_node", "(", "self", ",", ")", ":", "\"\"\"Return the current scenen node or create one if it does not exist\n\n :returns: Name of the scene node\n :rtype: str\n :raises: None\n \"\"\"", "scenenodes", "=", "cmds", ".", "ls", "(", "':jb_sceneNode*'", ")", "if", "len", "(", "scenenodes", ")", ">", "1", ":", "cmds", ".", "delete", "(", "scenenodes", ")", "node", "=", "jbscene", ".", "get_current_scene_node", "(", ")", "if", "node", "is", "None", ":", "cmds", ".", "namespace", "(", "set", "=", "':'", ")", "node", "=", "cmds", ".", "createNode", "(", "'jb_sceneNode'", ")", "return", "node", "def", "update_scene_node", "(", "self", ",", "tf", ")", ":", "\"\"\"Update the current scene node\n\n :param tf: the taskfile that is saved\n :type tf: :class:`djadapter.models.TaskFile`\n :returns: None\n :rtype: None\n :raises: None\n \"\"\"", "node", "=", "self", ".", "get_scene_node", "(", ")", "cmds", ".", "setAttr", "(", "'%s.taskfile_id'", "%", "node", ",", "lock", "=", "False", ")", "cmds", ".", "setAttr", "(", "'%s.taskfile_id'", "%", "node", ",", "tf", ".", "id", ")", "cmds", ".", "setAttr", "(", "'%s.taskfile_id'", "%", "node", ",", "lock", "=", "True", ")", "def", "check_modified", "(", "self", ",", ")", ":", "\"\"\"Check if the current scene was modified and ask the user to continue\n\n This might save the scene if the user accepts to save before continuing.\n\n :returns: True if the user accepted to continue.\n :rtype: bool\n :raises: None\n \"\"\"", "if", "not", "cmds", ".", "file", "(", "q", "=", "1", ",", "modified", "=", "1", ")", ":", "return", "True", "curfile", "=", "cmds", ".", "file", "(", "q", "=", "1", ",", "sceneName", "=", "1", ")", "r", "=", "cmds", ".", "confirmDialog", "(", "title", "=", "'Save Changes'", ",", "message", "=", "'Save changes to %s?'", "%", "curfile", ",", "button", "=", "[", "'Save'", ",", "'Don\\'t Save'", ",", "'Cancel'", "]", ",", "defaultButton", "=", "'Save'", ",", "cancelButton", "=", "'Cancel'", ",", "dismissString", "=", "'Cancel'", ")", "if", "r", "==", "'Cancel'", ":", "return", "False", "if", "r", "==", "'Save'", ":", "cmds", ".", "file", "(", "save", "=", "True", ",", "force", "=", "True", ")", "return", "True", "MayaGenesisWin", ".", "set_filetype", "(", "djadapter", ".", "FILETYPES", "[", "'mayamainscene'", "]", ",", ")", "return", "MayaGenesisWin" ]

[ "Subclass", "the", "given", "genesis", "class", "and", "implement", "all", "abstract", "methods" ]

[ "def", "get_identifiers", "(", "self", ")", ":", "for", "token", "in", "self", ".", "tokens", ":", "if", "not", "(", "token", ".", "is_whitespace", "or", "token", ".", "match", "(", "T", ".", "Punctuation", ",", "','", ")", ")", ":", "yield", "token" ]

[ "Returns", "the", "identifiers", "." ]

[ "async", "def", "connect", "(", "self", ",", "hostname", "=", "None", ",", "port", "=", "None", ",", "tls", "=", "False", ",", "*", "*", "kwargs", ")", ":", "if", "not", "port", ":", "if", "tls", ":", "port", "=", "DEFAULT_TLS_PORT", "else", ":", "port", "=", "rfc1459", ".", "protocol", ".", "DEFAULT_PORT", "return", "await", "super", "(", ")", ".", "connect", "(", "hostname", ",", "port", ",", "tls", "=", "tls", ",", "*", "*", "kwargs", ")" ]

[ "Connect", "to", "a", "server", "optionally", "over", "TLS", ".", "See", "pydle", ".", "features", ".", "RFC1459Support", ".", "connect", "for", "misc", "parameters", "." ]

[ "def", "get_parcellation", "(", "atlas", ",", "parcel_param", ")", ":", "parc_path", "=", "os", ".", "path", ".", "join", "(", "atlas", ",", "'parcellation_param{}.mgh'", ".", "format", "(", "parcel_param", ")", ")", "parcel", "=", "nibabel", ".", "freesurfer", ".", "io", ".", "read_geometry", "(", "parc_path", ")", "return", "parcel" ]

[ "Placeholder", "to", "insert", "your", "own", "function", "to", "return", "parcellation", "in", "reference", "space", "." ]

[ "def", "get_string", "(", "self", ",", "significant_figures", "=", "6", ")", ":", "ph", "=", "\"{:.%df}\"", "%", "significant_figures", "lines", "=", "[", "]", "for", "bound", ",", "d", "in", "zip", "(", "self", ".", "bounds", ",", "\"xyz\"", ")", ":", "fillers", "=", "bound", "+", "[", "d", "]", "*", "2", "bound_format", "=", "\" \"", ".", "join", "(", "[", "ph", "]", "*", "2", "+", "[", "\" {}lo {}hi\"", "]", ")", "lines", ".", "append", "(", "bound_format", ".", "format", "(", "*", "fillers", ")", ")", "if", "self", ".", "tilt", ":", "tilt_format", "=", "\" \"", ".", "join", "(", "[", "ph", "]", "*", "3", "+", "[", "\" xy xz yz\"", "]", ")", "lines", ".", "append", "(", "tilt_format", ".", "format", "(", "*", "self", ".", "tilt", ")", ")", "return", "\"\\n\"", ".", "join", "(", "lines", ")" ]

[ "Returns", "the", "string", "representation", "of", "simulation", "box", "in", "LAMMPS", "data", "file", "format", "." ]

[ "def", "send_is_typing", "(", "self", ",", "peer_jid", ":", "str", ",", "is_typing", ":", "bool", ")", ":", "if", "self", ".", "is_group_jid", "(", "peer_jid", ")", ":", "return", "self", ".", "_send_xmpp_element", "(", "chatting", ".", "OutgoingGroupIsTypingEvent", "(", "peer_jid", ",", "is_typing", ")", ")", "else", ":", "return", "self", ".", "_send_xmpp_element", "(", "chatting", ".", "OutgoingIsTypingEvent", "(", "peer_jid", ",", "is_typing", ")", ")" ]

[ "Updates", "the", "is", "typing", "status", "of", "the", "bot", "during", "a", "conversation", "." ]

[ "def", "_get_password", "(", "self", ",", "password", ",", "use_config", "=", "True", ",", "config_filename", "=", "None", ",", "use_keyring", "=", "HAS_KEYRING", ")", ":", "if", "not", "password", "and", "use_config", ":", "if", "self", ".", "_config", "is", "None", ":", "self", ".", "_read_config", "(", "config_filename", ")", "password", "=", "self", ".", "_config", ".", "get", "(", "\"credentials\"", ",", "\"password\"", ",", "fallback", "=", "None", ")", "if", "not", "password", "and", "use_keyring", ":", "logger", "=", "logging", ".", "getLogger", "(", "__name__", ")", "question", "=", "(", "\"Please enter your password for {} on {}: \"", ".", "format", "(", "self", ".", "username", ",", "self", ".", "host_base", ")", ")", "if", "HAS_KEYRING", ":", "password", "=", "keyring", ".", "get_password", "(", "self", ".", "keyring_identificator", ",", "self", ".", "username", ")", "if", "password", "is", "None", ":", "password", "=", "getpass", ".", "getpass", "(", "question", ")", "try", ":", "keyring", ".", "set_password", "(", "self", ".", "keyring_identificator", ",", "self", ".", "username", ",", "password", ")", "except", "keyring", ".", "errors", ".", "PasswordSetError", "as", "error", ":", "logger", ".", "warning", "(", "\"Storing password in keyring '%s' failed: %s\"", ",", "self", ".", "keyring_identificator", ",", "error", ")", "else", ":", "logger", ".", "warning", "(", "\"Install the 'keyring' Python module to store your password \"", "\"securely in your keyring!\"", ")", "password", "=", "self", ".", "_config", ".", "get", "(", "\"credentials\"", ",", "\"password\"", ",", "fallback", "=", "None", ")", "if", "password", "is", "None", ":", "password", "=", "getpass", ".", "getpass", "(", "question", ")", "store_plaintext_passwords", "=", "self", ".", "_config", ".", "get", "(", "\"preferences\"", ",", "\"store-plaintext-passwords\"", ",", "fallback", "=", "None", ")", "if", "store_plaintext_passwords", "!=", "\"no\"", ":", "question", "=", "(", "\"Do you want to store your password in plain text in \"", "+", "self", ".", "_config_filename", "(", ")", ")", "answer", "=", "ask", "(", "question", ",", "[", "\"yes\"", ",", "\"no\"", ",", "\"never\"", "]", ",", "\"no\"", ")", "if", "answer", "==", "\"yes\"", ":", "self", ".", "_config", ".", "set", "(", "\"credentials\"", ",", "\"password\"", ",", "password", ")", "self", ".", "_save_config", "(", ")", "elif", "answer", "==", "\"never\"", ":", "if", "\"preferences\"", "not", "in", "self", ".", "_config", ":", "self", ".", "_config", ".", "add_section", "(", "\"preferences\"", ")", "self", ".", "_config", ".", "set", "(", "\"preferences\"", ",", "\"store-plaintext-passwords\"", ",", "\"no\"", ")", "self", ".", "_save_config", "(", ")", "return", "password" ]

[ "Determine", "the", "user", "password" ]

[ "def", "get_by_page", "(", "query", ",", "page", ",", "page_size", ")", ":", "pager", "=", "Paginator", "(", "query", ",", "page_size", ")", "try", ":", "models", "=", "pager", ".", "page", "(", "page", ")", "except", "PageNotAnInteger", ":", "# If page is not an integer, deliver first page.", "models", "=", "pager", ".", "page", "(", "1", ")", "except", "EmptyPage", ":", "# If page is out of range (e.g. 9999), deliver last page of results.", "models", "=", "pager", ".", "page", "(", "pager", ".", "num_pages", ")", "return", "models" ]

[ "Осуществляет", "пагинацию", ":", "param", "query", ":", "запрос", ":", "param", "page", ":", "номер", "страницы", ":", "param", "page_size", ":", "количество", "объектов", "на", "странице", ":", "return", ":" ]

[ "def", "pull", "(", "collector", ",", "image", ",", "*", "*", "kwargs", ")", ":", "if", "not", "image", ".", "image_index", ":", "raise", "BadOption", "(", "\"The chosen image does not have a image_index configuration\"", ",", "wanted", "=", "image", ".", "name", ")", "tag", "=", "kwargs", "[", "\"artifact\"", "]", "if", "tag", "is", "NotSpecified", ":", "collector", ".", "configuration", "[", "\"harpoon\"", "]", ".", "tag", "if", "tag", "is", "not", "NotSpecified", ":", "image", ".", "tag", "=", "tag", "log", ".", "info", "(", "\"Pulling tag: %s\"", ",", "tag", ")", "Syncer", "(", ")", ".", "pull", "(", "image", ",", "ignore_missing", "=", "image", ".", "harpoon", ".", "ignore_missing", ")" ]

[ "Pull", "an", "image" ]

[ "def", "_parse_email", "(", "self", ",", "val", ")", ":", "ret", "=", "{", "'type'", ":", "None", ",", "'value'", ":", "None", "}", "try", ":", "ret", "[", "'type'", "]", "=", "val", "[", "1", "]", "[", "'type'", "]", "except", "(", "KeyError", ",", "ValueError", ",", "TypeError", ")", ":", "pass", "ret", "[", "'value'", "]", "=", "val", "[", "3", "]", ".", "strip", "(", ")", "try", ":", "self", ".", "vars", "[", "'email'", "]", ".", "append", "(", "ret", ")", "except", "AttributeError", ":", "self", ".", "vars", "[", "'email'", "]", "=", "[", "]", "self", ".", "vars", "[", "'email'", "]", ".", "append", "(", "ret", ")" ]

[ "The", "function", "for", "parsing", "the", "vcard", "email", "addresses", "." ]

[ "def", "schedule_recurring", "(", "interval", ",", "target", "=", "None", ",", "maxtimes", "=", "0", ",", "starting_at", "=", "0", ",", "args", "=", "(", ")", ",", "kwargs", "=", "None", ")", ":", "starting_at", "=", "starting_at", "or", "time", ".", "time", "(", ")", "if", "target", "is", "None", ":", "def", "decorator", "(", "target", ")", ":", "return", "schedule_recurring", "(", "interval", ",", "target", ",", "maxtimes", ",", "starting_at", ",", "args", ",", "kwargs", ")", "return", "decorator", "func", "=", "target", "if", "isinstance", "(", "target", ",", "compat", ".", "greenlet", ")", "or", "target", "is", "compat", ".", "main_greenlet", ":", "if", "target", ".", "dead", ":", "raise", "TypeError", "(", "\"can't schedule a dead greenlet\"", ")", "func", "=", "target", ".", "run", "def", "run_and_schedule_one", "(", "tstamp", ",", "count", ")", ":", "# pass in the time scheduled instead of just checking", "# time.time() so that delays don't add up", "if", "not", "maxtimes", "or", "count", "<", "maxtimes", ":", "tstamp", "+=", "interval", "func", "(", "*", "args", ",", "*", "*", "(", "kwargs", "or", "{", "}", ")", ")", "schedule_at", "(", "tstamp", ",", "run_and_schedule_one", ",", "args", "=", "(", "tstamp", ",", "count", "+", "1", ")", ")", "firstrun", "=", "starting_at", "+", "interval", "schedule_at", "(", "firstrun", ",", "run_and_schedule_one", ",", "args", "=", "(", "firstrun", ",", "0", ")", ")", "return", "target" ]

[ "insert", "a", "greenlet", "into", "the", "scheduler", "to", "run", "regularly", "at", "an", "interval" ]

[ "def", "_clean_data", "(", "api_response", ")", ":", "data", "=", "{", "}", "data", ".", "update", "(", "api_response", "[", "'DATA'", "]", ")", "if", "not", "data", ":", "response_data", "=", "api_response", "[", "'DATA'", "]", "data", ".", "update", "(", "response_data", ")", "return", "data" ]

[ "Returns", "the", "DATA", "response", "from", "a", "Linode", "API", "query", "as", "a", "single", "pre", "-", "formatted", "dictionary" ]

[ "def", "create_multilevel_chunker", "(", "self", ",", "chunk_sizes", ")", ":", "rolling_hash", "=", "_rabinkarprh", ".", "RabinKarpMultiThresholdHash", "(", "self", ".", "window_size", ",", "self", ".", "_seed", ",", "[", "1.0", "/", "chunk_size", "for", "chunk_size", "in", "chunk_sizes", "]", ")", "return", "RabinKarpCDC", ".", "_MultiLevelChunker", "(", "rolling_hash", ")" ]

[ "Create", "a", "multi", "-", "level", "chunker", "performing", "content", "-", "defined", "chunking", "(", "CDC", ")", "using", "Rabin", "Karp", "s", "rolling", "hash", "scheme", "with", "different", "specific", "expected", "chunk", "sizes", "." ]

[ "def", "get", "(", "self", ",", "version", ")", ":", "version_found", "=", "False", "api_spec", "=", "self", ".", "_create_api_spec", "(", "version", ")", "for", "base_api", "in", "current_app", ".", "appbuilder", ".", "baseviews", ":", "if", "isinstance", "(", "base_api", ",", "BaseApi", ")", "and", "base_api", ".", "version", "==", "version", ":", "base_api", ".", "add_api_spec", "(", "api_spec", ")", "version_found", "=", "True", "if", "version_found", ":", "return", "self", ".", "response", "(", "200", ",", "*", "*", "api_spec", ".", "to_dict", "(", ")", ")", "else", ":", "return", "self", ".", "response_404", "(", ")" ]

[ "Endpoint", "that", "renders", "an", "OpenApi", "spec", "for", "all", "views", "that", "belong", "to", "a", "certain", "version", "---", "get", ":", "parameters", ":", "-", "in", ":", "path", "schema", ":", "type", ":", "string", "name", ":", "version", "responses", ":", "200", ":", "description", ":", "Item", "from", "Model", "content", ":", "application", "/", "json", ":", "schema", ":", "type", ":", "object", "404", ":", "$ref", ":", "#", "/", "components", "/", "responses", "/", "404", "500", ":", "$ref", ":", "#", "/", "components", "/", "responses", "/", "500" ]

[ "def", "threeprime_plot", "(", "self", ")", ":", "data", "=", "dict", "(", ")", "dict_to_add", "=", "dict", "(", ")", "# Create tuples out of entries", "for", "key", "in", "self", ".", "threepGtoAfreq_data", ":", "pos", "=", "list", "(", "range", "(", "1", ",", "len", "(", "self", ".", "threepGtoAfreq_data", ".", "get", "(", "key", ")", ")", ")", ")", "#Multiply values by 100 to get %", "tmp", "=", "[", "i", "*", "100.0", "for", "i", "in", "self", ".", "threepGtoAfreq_data", ".", "get", "(", "key", ")", "]", "tuples", "=", "list", "(", "zip", "(", "pos", ",", "tmp", ")", ")", "# Get a dictionary out of it", "data", "=", "dict", "(", "(", "x", ",", "y", ")", "for", "x", ",", "y", "in", "tuples", ")", "dict_to_add", "[", "key", "]", "=", "data", "config", "=", "{", "'id'", ":", "'threeprime_misinc_plot'", ",", "'title'", ":", "'DamageProfiler: 3P G>A misincorporation plot'", ",", "'ylab'", ":", "'% G to A substituted'", ",", "'xlab'", ":", "'Nucleotide position from 3\\''", ",", "'tt_label'", ":", "'{point.y:.2f} % G>A misincorporations at nucleotide position {point.x}'", ",", "'ymin'", ":", "0", ",", "'xmin'", ":", "1", "}", "return", "linegraph", ".", "plot", "(", "dict_to_add", ",", "config", ")" ]

[ "Generate", "a", "3", "G", ">", "A", "linegraph", "plot" ]

[ "def", "_pystate_to_npstate", "(", "pystate", ")", ":", "NP_VERSION", "=", "'MT19937'", "version", ",", "keys_pos_", ",", "cached_gaussian_", "=", "pystate", "keys", ",", "pos", "=", "keys_pos_", "[", ":", "-", "1", "]", ",", "keys_pos_", "[", "-", "1", "]", "keys", "=", "np", ".", "array", "(", "keys", ",", "dtype", "=", "np", ".", "uint32", ")", "has_gauss", "=", "cached_gaussian_", "is", "not", "None", "cached_gaussian", "=", "cached_gaussian_", "if", "has_gauss", "else", "0.0", "npstate", "=", "(", "NP_VERSION", ",", "keys", ",", "pos", ",", "has_gauss", ",", "cached_gaussian", ")", "return", "npstate" ]

[ "Convert", "state", "of", "a", "Python", "Random", "object", "to", "state", "usable", "by", "NumPy", "RandomState", "." ]

[ "def", "graphcut_stawiaski", "(", "regions", ",", "gradient", "=", "False", ",", "foreground", "=", "False", ",", "background", "=", "False", ")", ":", "# initialize logger", "logger", "=", "Logger", ".", "getInstance", "(", ")", "# unpack images if required", "# !TODO: This is an ugly hack, especially since it can be seen inside the function definition", "# How to overcome this, since I can not use a wrapper function as the whole thing must be pickable", "if", "not", "gradient", "and", "not", "foreground", "and", "not", "background", ":", "regions", ",", "gradient", ",", "foreground", ",", "background", "=", "regions", "# ensure that input images are scipy arrays", "img_region", "=", "scipy", ".", "asarray", "(", "regions", ")", "img_gradient", "=", "scipy", ".", "asarray", "(", "gradient", ")", "img_fg", "=", "scipy", ".", "asarray", "(", "foreground", ",", "dtype", "=", "scipy", ".", "bool_", ")", "img_bg", "=", "scipy", ".", "asarray", "(", "background", ",", "dtype", "=", "scipy", ".", "bool_", ")", "# ensure correctness of supplied images", "if", "not", "(", "img_region", ".", "shape", "==", "img_gradient", ".", "shape", "==", "img_fg", ".", "shape", "==", "img_bg", ".", "shape", ")", ":", "raise", "ArgumentError", "(", "'All supplied images must be of the same shape.'", ")", "# recompute the label ids to start from id = 1", "img_region", "=", "relabel", "(", "img_region", ")", "# generate graph", "gcgraph", "=", "graph_from_labels", "(", "img_region", ",", "img_fg", ",", "img_bg", ",", "boundary_term", "=", "boundary_stawiaski", ",", "boundary_term_args", "=", "(", "img_gradient", ")", ")", "# execute min-cut", "maxflow", "=", "gcgraph", ".", "maxflow", "(", ")", "# executes the cut and returns the maxflow value", "logger", ".", "debug", "(", "'Graph-cut terminated successfully with maxflow of {}.'", ".", "format", "(", "maxflow", ")", ")", "# apply results to the region image", "mapping", "=", "[", "0", "]", "# no regions with id 1 exists in mapping, entry used as padding", "mapping", ".", "extend", "(", "[", "0", "if", "gcgraph", ".", "termtype", ".", "SINK", "==", "gcgraph", ".", "what_segment", "(", "int", "(", "x", ")", "-", "1", ")", "else", "1", "for", "x", "in", "scipy", ".", "unique", "(", "img_region", ")", "]", ")", "img_results", "=", "relabel_map", "(", "img_region", ",", "mapping", ")", "return", "img_results", ".", "astype", "(", "scipy", ".", "bool_", ")" ]

[ "Executes", "a", "Stawiaski", "label", "graph", "cut", ".", "Parameters", "----------", "regions", ":", "ndarray", "The", "regions", "image", "/", "label", "map", ".", "gradient", ":", "ndarray", "The", "gradient", "image", ".", "foreground", ":", "ndarray", "The", "foreground", "markers", ".", "background", ":", "ndarray", "The", "background", "markers", ".", "Returns", "-------", "segmentation", ":", "ndarray", "The", "graph", "-", "cut", "segmentation", "result", "as", "boolean", "array", ".", "Raises", "------", "ArgumentError", "When", "the", "supplied", "data", "is", "erroneous", "." ]

[ "def", "state_dict", "(", "self", ")", "->", "Dict", "[", "str", ",", "Any", "]", ":", "return", "{", "key", ":", "value", "for", "key", ",", "value", "in", "self", ".", "__dict__", ".", "items", "(", ")", "if", "key", "!=", "'optimizer'", "}" ]

[ "Returns", "the", "state", "of", "the", "scheduler", "as", "a", "dict", "." ]

[ "def", "settimeout", "(", "self", ",", "timeout", ")", ":", "self", ".", "sock_opt", ".", "timeout", "=", "timeout", "if", "self", ".", "sock", ":", "self", ".", "sock", ".", "settimeout", "(", "timeout", ")" ]

[ "Set", "the", "timeout", "to", "the", "websocket", "." ]

[ "def", "P", "(", "self", ")", ":", "try", ":", "return", "self", ".", "_diff_op", "except", "AttributeError", ":", "self", ".", "_diff_op", "=", "normalize", "(", "self", ".", "kernel", ",", "'l1'", ",", "axis", "=", "1", ")", "return", "self", ".", "_diff_op" ]

[ "Diffusion", "operator", "(", "cached", ")" ]

[ "def", "find_expected_error", "(", "self", ",", "delta_params", "=", "'calc'", ",", "adjust", "=", "True", ")", ":", "expected_error", "=", "super", "(", "LMGlobals", ",", "self", ")", ".", "find_expected_error", "(", "delta_params", "=", "delta_params", ")", "if", "adjust", ":", "#adjust for num_pix", "derr", "=", "(", "expected_error", "-", "self", ".", "error", ")", "*", "(", "self", ".", "state", ".", "residuals", ".", "size", "/", "float", "(", "self", ".", "num_pix", ")", ")", "expected_error", "=", "self", ".", "error", "+", "derr", "return", "expected_error" ]

[ "Returns", "the", "error", "expected", "after", "an", "update", "if", "the", "model", "were", "linear", "." ]

[ "def", "Execute", "(", "self", ",", "action", ",", "*", "args", ",", "*", "*", "kw", ")", ":", "action", "=", "self", ".", "Action", "(", "action", ",", "*", "args", ",", "*", "*", "kw", ")", "result", "=", "action", "(", "[", "]", ",", "[", "]", ",", "self", ")", "if", "isinstance", "(", "result", ",", "SCons", ".", "Errors", ".", "BuildError", ")", ":", "errstr", "=", "result", ".", "errstr", "if", "result", ".", "filename", ":", "errstr", "=", "result", ".", "filename", "+", "': '", "+", "errstr", "sys", ".", "stderr", ".", "write", "(", "\"scons: *** %s\\n\"", "%", "errstr", ")", "return", "result", ".", "status", "else", ":", "return", "result" ]

[ "Directly", "execute", "an", "action", "through", "an", "Environment" ]

[ "def", "parse_obj", "(", "o", ")", ":", "r", "=", "{", "}", "for", "k", ",", "v", "in", "o", ".", "items", "(", ")", ":", "if", "is_unable_to_connect", "(", "v", ")", ":", "r", "[", "k", "]", "=", "None", "try", ":", "r", "[", "k", "]", "=", "parse_value", "(", "k", ",", "v", ")", "except", "(", "ObdPidParserUnknownError", ",", "AttributeError", ",", "TypeError", ")", ":", "r", "[", "k", "]", "=", "None", "return", "r" ]

[ "Parses", "a", "given", "dictionary", "with", "the", "key", "being", "the", "OBD", "PID", "and", "the", "value", "its", "returned", "value", "by", "the", "OBD", "interface", ":", "param", "dict", "o", ":", ":", "return", ":" ]

[ "def", "read_interface", "(", "self", ")", ":", "# Spin up the packet capture", "if", "self", ".", "_iface_is_file", "(", ")", ":", "self", ".", "pcap", "=", "pcapy", ".", "open_offline", "(", "self", ".", "iface_name", ")", "else", ":", "try", ":", "# self.pcap = pcap.pcap(name=self.iface_name, promisc=True, immediate=True)", "# snaplen (maximum number of bytes to capture _per_packet_)", "# promiscious mode (1 for true)", "# timeout (in milliseconds)", "self", ".", "pcap", "=", "pcapy", ".", "open_live", "(", "self", ".", "iface_name", ",", "65536", ",", "1", ",", "0", ")", "except", "OSError", ":", "try", ":", "logger", ".", "warning", "(", "'Could not get promisc mode, turning flag off'", ")", "self", ".", "pcap", "=", "pcapy", ".", "open_live", "(", "self", ".", "iface_name", ",", "65536", ",", "0", ",", "0", ")", "except", "OSError", ":", "log_utils", ".", "panic", "(", "'Could no open interface with any options (may need to be sudo)'", ")", "# Add the BPF if it's specified", "if", "self", ".", "bpf", ":", "self", ".", "pcap", ".", "setfilter", "(", "self", ".", "bpf", ")", "print", "(", "'listening on %s: %s'", "%", "(", "self", ".", "iface_name", ",", "self", ".", "bpf", ")", ")", "# For each packet in the pcap process the contents", "_packets", "=", "0", "while", "True", ":", "# Grab the next header and packet buffer", "header", ",", "raw_buf", "=", "self", ".", "pcap", ".", "next", "(", ")", "# If we don't get a packet header break out of the loop", "if", "not", "header", ":", "break", "# Extract the timestamp from the header and yield the packet", "seconds", ",", "micro_sec", "=", "header", ".", "getts", "(", ")", "timestamp", "=", "seconds", "+", "micro_sec", "*", "10", "**", "-", "6", "yield", "{", "'timestamp'", ":", "timestamp", ",", "'raw_buf'", ":", "raw_buf", ",", "'packet_num'", ":", "_packets", "}", "_packets", "+=", "1", "# Is there a max packets set if so break on it", "if", "self", ".", "max_packets", "and", "_packets", ">=", "self", ".", "max_packets", ":", "break", "# All done so report and raise a StopIteration", "try", ":", "print", "(", "'Packet stats: %d received, %d dropped, %d dropped by interface'", "%", "self", ".", "pcap", ".", "stats", "(", ")", ")", "except", "pcapy", ".", "PcapError", ":", "print", "(", "'No stats available...'", ")", "raise", "StopIteration" ]

[ "Read", "Packets", "from", "the", "packet", "capture", "interface" ]

[ "def", "start_transmit", "(", "self", ",", "fd", ",", "data", "=", "None", ")", ":", "self", ".", "_wfds", "[", "fd", "]", "=", "(", "data", "or", "fd", ",", "self", ".", "_generation", ")", "self", ".", "_update", "(", "fd", ")" ]

[ "Cause", ":", "meth", ":", "poll", "to", "yield", "data", "when", "fd", "is", "writeable", "." ]

[ "def", "average_returns", "(", "ts", ",", "*", "*", "kwargs", ")", ":", "average_type", "=", "kwargs", ".", "get", "(", "'type'", ",", "'net'", ")", "if", "average_type", "==", "'net'", ":", "relative", "=", "0", "else", ":", "relative", "=", "-", "1", "# gross", "#start = kwargs.get('start', ts.index[0])", "#end = kwargs.get('end', ts.index[len(ts.index) - 1])", "#delta = kwargs.get('delta', ts.index[1] - ts.index[0])", "period", "=", "kwargs", ".", "get", "(", "'period'", ",", "None", ")", "if", "isinstance", "(", "period", ",", "int", ")", ":", "pass", "#else:", "#ts = reIndexDF(ts, start=start, end=end, delta=delta)", "#period = 1", "avg_ret", "=", "1", "for", "idx", "in", "range", "(", "len", "(", "ts", ".", "index", ")", ")", ":", "if", "idx", "%", "period", "==", "0", ":", "avg_ret", "*=", "(", "1", "+", "ts", "[", "idx", "]", "+", "relative", ")", "return", "avg_ret", "-", "1" ]

[ "Compute", "geometric", "average", "returns", "from", "a", "returns", "time", "serie" ]

[ "def", "delete", "(", "self", ",", "custom_field", ",", "params", "=", "{", "}", ",", "*", "*", "options", ")", ":", "path", "=", "\"/custom_fields/%s\"", "%", "(", "custom_field", ")", "return", "self", ".", "client", ".", "delete", "(", "path", ",", "params", ",", "*", "*", "options", ")" ]

[ "A", "specific", "existing", "custom", "field", "can", "be", "deleted", "by", "making", "a", "DELETE", "request", "on", "the", "URL", "for", "that", "custom", "field", ".", "Returns", "an", "empty", "data", "record", "." ]

[ "def", "create_forwarding_script", "(", "filepath", ",", "module", ",", "func_name", ",", "*", "nargs", ",", "*", "*", "kwargs", ")", ":", "doc", "=", "dict", "(", "module", "=", "module", ",", "func_name", "=", "func_name", ")", "if", "nargs", ":", "doc", "[", "\"nargs\"", "]", "=", "nargs", "if", "kwargs", ":", "doc", "[", "\"kwargs\"", "]", "=", "kwargs", "body", "=", "dump_yaml", "(", "doc", ")", "create_executable_script", "(", "filepath", ",", "body", ",", "\"_rez_fwd\"", ")" ]

[ "Create", "a", "forwarding", "script", "." ]

[ "def", "in_", "(", "self", ",", "qfield", ",", "*", "values", ")", ":", "# TODO: make sure that this field represents a list", "qfield", "=", "resolve_name", "(", "self", ".", "type", ",", "qfield", ")", "self", ".", "filter", "(", "QueryExpression", "(", "{", "qfield", ":", "{", "'$in'", ":", "[", "qfield", ".", "wrap_value", "(", "value", ")", "for", "value", "in", "values", "]", "}", "}", ")", ")", "return", "self" ]

[ "Check", "to", "see", "that", "the", "value", "of", "qfield", "is", "one", "of", "values" ]

[ "def", "djrepo_path", "(", "self", ")", ":", "root", ",", "ext", "=", "os", ".", "path", ".", "splitext", "(", "self", ".", "filepath", ")", "path", "=", "root", "+", "\".djrepo\"", "return", "path" ]

[ "The", "path", "of", "the", "djrepo", "file", ".", "None", "if", "file", "does", "not", "exist", "." ]

[ "def", "get", "(", "version", ":", "str", ")", "->", "'Protocol'", ":", "return", "Protocol", ".", "V_13", "if", "version", "==", "Protocol", ".", "V_13", ".", "value", ".", "name", "else", "Protocol", ".", "DEFAULT" ]

[ "Return", "enum", "instance", "corresponding", "to", "input", "version", "value", "(", "1", ".", "6", "etc", ".", ")" ]

[ "def", "left_press", "(", "self", ",", "event", ")", ":", "self", ".", "current_coords", "=", "self", ".", "canvas", ".", "canvasx", "(", "event", ".", "x", ")", ",", "self", ".", "canvas", ".", "canvasy", "(", "event", ".", "y", ")", "self", ".", "set_current", "(", ")", "if", "self", ".", "current", ":", "self", ".", "canvas", ".", "itemconfigure", "(", "self", ".", "current", ",", "fill", "=", "self", ".", "item_colors", "[", "self", ".", "current", "]", "[", "1", "]", ")", "self", ".", "current", "=", "None", "return", "results", "=", "self", ".", "canvas", ".", "find_withtag", "(", "tk", ".", "CURRENT", ")", "if", "len", "(", "results", ")", "is", "0", ":", "return", "self", ".", "current", "=", "results", "[", "0", "]", "self", ".", "canvas", ".", "itemconfigure", "(", "self", ".", "current", ",", "fill", "=", "self", ".", "item_colors", "[", "self", ".", "current", "]", "[", "2", "]", ")" ]

[ "Callback", "for", "the", "press", "of", "the", "left", "mouse", "button", "." ]

[ "def", "write_vector_window", "(", "in_data", "=", "None", ",", "out_schema", "=", "None", ",", "out_tile", "=", "None", ",", "out_path", "=", "None", ",", "bucket_resource", "=", "None", ")", ":", "# Delete existing file.", "try", ":", "os", ".", "remove", "(", "out_path", ")", "except", "OSError", ":", "pass", "out_features", "=", "[", "]", "for", "feature", "in", "in_data", ":", "try", ":", "# clip feature geometry to tile bounding box and append for writing", "# if clipped feature still", "for", "out_geom", "in", "multipart_to_singleparts", "(", "clean_geometry_type", "(", "to_shape", "(", "feature", "[", "\"geometry\"", "]", ")", ".", "intersection", "(", "out_tile", ".", "bbox", ")", ",", "out_schema", "[", "\"geometry\"", "]", ")", ")", ":", "out_features", ".", "append", "(", "{", "\"geometry\"", ":", "mapping", "(", "out_geom", ")", ",", "\"properties\"", ":", "feature", "[", "\"properties\"", "]", "}", ")", "except", "Exception", "as", "e", ":", "logger", ".", "warning", "(", "\"failed to prepare geometry for writing: %s\"", ",", "e", ")", "continue", "# write if there are output features", "if", "out_features", ":", "try", ":", "if", "out_path", ".", "startswith", "(", "\"s3://\"", ")", ":", "# write data to remote file", "with", "VectorWindowMemoryFile", "(", "tile", "=", "out_tile", ",", "features", "=", "out_features", ",", "schema", "=", "out_schema", ",", "driver", "=", "\"GeoJSON\"", ")", "as", "memfile", ":", "logger", ".", "debug", "(", "(", "out_tile", ".", "id", ",", "\"upload tile\"", ",", "out_path", ")", ")", "bucket_resource", ".", "put_object", "(", "Key", "=", "\"/\"", ".", "join", "(", "out_path", ".", "split", "(", "\"/\"", ")", "[", "3", ":", "]", ")", ",", "Body", "=", "memfile", ")", "else", ":", "# write data to local file", "with", "fiona", ".", "open", "(", "out_path", ",", "'w'", ",", "schema", "=", "out_schema", ",", "driver", "=", "\"GeoJSON\"", ",", "crs", "=", "out_tile", ".", "crs", ".", "to_dict", "(", ")", ")", "as", "dst", ":", "logger", ".", "debug", "(", "(", "out_tile", ".", "id", ",", "\"write tile\"", ",", "out_path", ")", ")", "dst", ".", "writerecords", "(", "out_features", ")", "except", "Exception", "as", "e", ":", "logger", ".", "error", "(", "\"error while writing file %s: %s\"", ",", "out_path", ",", "e", ")", "raise", "else", ":", "logger", ".", "debug", "(", "(", "out_tile", ".", "id", ",", "\"nothing to write\"", ",", "out_path", ")", ")" ]

[ "Write", "features", "to", "GeoJSON", "file", "." ]

[ "def", "store", "(", "self", ")", ":", "output", "=", "tempfile", ".", "NamedTemporaryFile", "(", "suffix", "=", "'.json'", ")", "try", ":", "def", "write", "(", "o", ")", ":", "line", "=", "json", ".", "dumps", "(", "o", ",", "default", "=", "json_default", ")", "return", "output", ".", "write", "(", "line", "+", "'\\n'", ")", "yield", "write", "output", ".", "seek", "(", "0", ")", "log", ".", "info", "(", "\"Uploading generated table (%s)...\"", ",", "self", ".", "_obj", ")", "self", ".", "save_file", "(", "output", ".", "name", ",", "destructive", "=", "True", ")", "finally", ":", "try", ":", "output", ".", "close", "(", ")", "except", ":", "pass" ]

[ "Create", "a", "context", "manager", "to", "store", "records", "in", "the", "cleaned", "table", "." ]

[ "def", "jacobian_augmentation", "(", "sess", ",", "x", ",", "X_sub_prev", ",", "Y_sub", ",", "grads", ",", "lmbda", ",", "aug_batch_size", "=", "512", ",", "feed", "=", "None", ")", ":", "assert", "len", "(", "x", ".", "get_shape", "(", ")", ")", "==", "len", "(", "np", ".", "shape", "(", "X_sub_prev", ")", ")", "assert", "len", "(", "grads", ")", ">=", "np", ".", "max", "(", "Y_sub", ")", "+", "1", "assert", "len", "(", "X_sub_prev", ")", "==", "len", "(", "Y_sub", ")", "aug_batch_size", "=", "min", "(", "aug_batch_size", ",", "X_sub_prev", ".", "shape", "[", "0", "]", ")", "# Prepare input_shape (outside loop) for feeding dictionary below", "input_shape", "=", "list", "(", "x", ".", "get_shape", "(", ")", ")", "input_shape", "[", "0", "]", "=", "1", "# Create new numpy array for adversary training data", "# with twice as many components on the first dimension.", "X_sub", "=", "np", ".", "vstack", "(", "[", "X_sub_prev", ",", "X_sub_prev", "]", ")", "num_samples", "=", "X_sub_prev", ".", "shape", "[", "0", "]", "# Creating and processing as batch", "for", "p_idxs", "in", "range", "(", "0", ",", "num_samples", ",", "aug_batch_size", ")", ":", "X_batch", "=", "X_sub_prev", "[", "p_idxs", ":", "p_idxs", "+", "aug_batch_size", ",", "...", "]", "feed_dict", "=", "{", "x", ":", "X_batch", "}", "if", "feed", "is", "not", "None", ":", "feed_dict", ".", "update", "(", "feed", ")", "# Compute sign matrix", "grad_val", "=", "sess", ".", "run", "(", "[", "tf", ".", "sign", "(", "grads", ")", "]", ",", "feed_dict", "=", "feed_dict", ")", "[", "0", "]", "# Create new synthetic point in adversary substitute training set", "for", "(", "indx", ",", "ind", ")", "in", "zip", "(", "range", "(", "p_idxs", ",", "p_idxs", "+", "X_batch", ".", "shape", "[", "0", "]", ")", ",", "range", "(", "X_batch", ".", "shape", "[", "0", "]", ")", ")", ":", "X_sub", "[", "num_samples", "+", "indx", "]", "=", "(", "X_batch", "[", "ind", "]", "+", "lmbda", "*", "grad_val", "[", "Y_sub", "[", "indx", "]", ",", "ind", ",", "...", "]", ")", "# Return augmented training data (needs to be labeled afterwards)", "return", "X_sub" ]

[ "Augment", "an", "adversary", "s", "substitute", "training", "set", "using", "the", "Jacobian", "of", "a", "substitute", "model", "to", "generate", "new", "synthetic", "inputs", ".", "See", "https", ":", "//", "arxiv", ".", "org", "/", "abs", "/", "1602", ".", "02697", "for", "more", "details", ".", "See", "cleverhans_tutorials", "/", "mnist_blackbox", ".", "py", "for", "example", "use", "case", ":", "param", "sess", ":", "TF", "session", "in", "which", "the", "substitute", "model", "is", "defined", ":", "param", "x", ":", "input", "TF", "placeholder", "for", "the", "substitute", "model", ":", "param", "X_sub_prev", ":", "substitute", "training", "data", "available", "to", "the", "adversary", "at", "the", "previous", "iteration", ":", "param", "Y_sub", ":", "substitute", "training", "labels", "available", "to", "the", "adversary", "at", "the", "previous", "iteration", ":", "param", "grads", ":", "Jacobian", "symbolic", "graph", "for", "the", "substitute", "(", "should", "be", "generated", "using", "utils_tf", ".", "jacobian_graph", ")", ":", "return", ":", "augmented", "substitute", "data", "(", "will", "need", "to", "be", "labeled", "by", "oracle", ")" ]

[ "def", "_Bound_Ph", "(", "P", ",", "h", ")", ":", "region", "=", "None", "if", "Pmin", "<=", "P", "<=", "Ps_623", ":", "h14", "=", "_Region1", "(", "_TSat_P", "(", "P", ")", ",", "P", ")", "[", "\"h\"", "]", "h24", "=", "_Region2", "(", "_TSat_P", "(", "P", ")", ",", "P", ")", "[", "\"h\"", "]", "h25", "=", "_Region2", "(", "1073.15", ",", "P", ")", "[", "\"h\"", "]", "hmin", "=", "_Region1", "(", "273.15", ",", "P", ")", "[", "\"h\"", "]", "hmax", "=", "_Region5", "(", "2273.15", ",", "P", ")", "[", "\"h\"", "]", "if", "hmin", "<=", "h", "<=", "h14", ":", "region", "=", "1", "elif", "h14", "<", "h", "<", "h24", ":", "region", "=", "4", "elif", "h24", "<=", "h", "<=", "h25", ":", "region", "=", "2", "elif", "h25", "<", "h", "<=", "hmax", ":", "region", "=", "5", "elif", "Ps_623", "<", "P", "<", "Pc", ":", "hmin", "=", "_Region1", "(", "273.15", ",", "P", ")", "[", "\"h\"", "]", "h13", "=", "_Region1", "(", "623.15", ",", "P", ")", "[", "\"h\"", "]", "h32", "=", "_Region2", "(", "_t_P", "(", "P", ")", ",", "P", ")", "[", "\"h\"", "]", "h25", "=", "_Region2", "(", "1073.15", ",", "P", ")", "[", "\"h\"", "]", "hmax", "=", "_Region5", "(", "2273.15", ",", "P", ")", "[", "\"h\"", "]", "if", "hmin", "<=", "h", "<=", "h13", ":", "region", "=", "1", "elif", "h13", "<", "h", "<", "h32", ":", "try", ":", "p34", "=", "_PSat_h", "(", "h", ")", "except", "NotImplementedError", ":", "p34", "=", "Pc", "if", "P", "<", "p34", ":", "region", "=", "4", "else", ":", "region", "=", "3", "elif", "h32", "<=", "h", "<=", "h25", ":", "region", "=", "2", "elif", "h25", "<", "h", "<=", "hmax", ":", "region", "=", "5", "elif", "Pc", "<=", "P", "<=", "100", ":", "hmin", "=", "_Region1", "(", "273.15", ",", "P", ")", "[", "\"h\"", "]", "h13", "=", "_Region1", "(", "623.15", ",", "P", ")", "[", "\"h\"", "]", "h32", "=", "_Region2", "(", "_t_P", "(", "P", ")", ",", "P", ")", "[", "\"h\"", "]", "h25", "=", "_Region2", "(", "1073.15", ",", "P", ")", "[", "\"h\"", "]", "hmax", "=", "_Region5", "(", "2273.15", ",", "P", ")", "[", "\"h\"", "]", "if", "hmin", "<=", "h", "<=", "h13", ":", "region", "=", "1", "elif", "h13", "<", "h", "<", "h32", ":", "region", "=", "3", "elif", "h32", "<=", "h", "<=", "h25", ":", "region", "=", "2", "elif", "P", "<=", "50", "and", "h25", "<=", "h", "<=", "hmax", ":", "region", "=", "5", "return", "region" ]

[ "Region", "definition", "for", "input", "P", "y", "h" ]

[ "def", "stream_json_file", "(", "local_file", ")", ":", "for", "i", ",", "line", "in", "enumerate", "(", "local_file", ")", ":", "try", ":", "data", "=", "json", ".", "loads", "(", "line", ".", "decode", "(", "'utf-8'", ")", ")", "yield", "data", "except", "ValueError", "as", "e", ":", "logging", ".", "warning", "(", "\"Skipping line %d due to error: %s\"", ",", "i", ",", "e", ")", "continue" ]

[ "Stream", "a", "JSON", "file", "(", "in", "JSON", "-", "per", "-", "line", "format", ")" ]

[ "def", "write_dot_file", "(", "G", ",", "filename", ")", ":", "with", "io", ".", "open", "(", "filename", ",", "\"w\"", ")", "as", "fh", ":", "fh", ".", "write", "(", "\"strict digraph DependencyDiagram {\\n\"", ")", "edge_list", "=", "G", ".", "edges", "(", ")", "node_list", "=", "set", "(", "G", ".", "nodes", "(", ")", ")", "if", "edge_list", ":", "for", "edge", "in", "sorted", "(", "edge_list", ")", ":", "source", ",", "targ", "=", "edge", "node_list", "=", "node_list", "-", "set", "(", "source", ")", "node_list", "=", "node_list", "-", "set", "(", "targ", ")", "line", "=", "'\"{}\" -> \"{}\";\\n'", "fh", ".", "write", "(", "line", ".", "format", "(", "source", ",", "targ", ")", ")", "# draw nodes with no links", "if", "node_list", ":", "for", "node", "in", "sorted", "(", "node_list", ")", ":", "line", "=", "'\"{}\"\\n'", ".", "format", "(", "node", ")", "fh", ".", "write", "(", "line", ")", "fh", ".", "write", "(", "\"}\"", ")" ]

[ "Writes", "the", "graph", "G", "in", "dot", "file", "format", "for", "graphviz", "visualization", "." ]

[ "def", "create_supercut_in_batches", "(", "composition", ",", "outputfile", ",", "padding", ")", ":", "total_clips", "=", "len", "(", "composition", ")", "start_index", "=", "0", "end_index", "=", "BATCH_SIZE", "batch_comp", "=", "[", "]", "while", "start_index", "<", "total_clips", ":", "filename", "=", "outputfile", "+", "'.tmp'", "+", "str", "(", "start_index", ")", "+", "'.mp4'", "try", ":", "create_supercut", "(", "composition", "[", "start_index", ":", "end_index", "]", ",", "filename", ",", "padding", ")", "batch_comp", ".", "append", "(", "filename", ")", "gc", ".", "collect", "(", ")", "start_index", "+=", "BATCH_SIZE", "end_index", "+=", "BATCH_SIZE", "except", ":", "start_index", "+=", "BATCH_SIZE", "end_index", "+=", "BATCH_SIZE", "next", "clips", "=", "[", "VideoFileClip", "(", "filename", ")", "for", "filename", "in", "batch_comp", "]", "video", "=", "concatenate", "(", "clips", ")", "video", ".", "to_videofile", "(", "outputfile", ",", "codec", "=", "\"libx264\"", ",", "temp_audiofile", "=", "'temp-audio.m4a'", ",", "remove_temp", "=", "True", ",", "audio_codec", "=", "'aac'", ")", "# remove partial video files", "for", "filename", "in", "batch_comp", ":", "os", ".", "remove", "(", "filename", ")", "cleanup_log_files", "(", "outputfile", ")" ]

[ "Create", "&", "concatenate", "video", "clips", "in", "groups", "of", "size", "BATCH_SIZE", "and", "output", "finished", "video", "file", "to", "output", "directory", "." ]

[ "def", "escape", "(", "x", ",", "lb", "=", "False", ")", ":", "# Insert a linebreak? Roughly around the middle of the string,", "if", "lb", ":", "l", "=", "len", "(", "x", ")", "if", "l", ">=", "10", ":", "l", ">>=", "1", "# middle of the string", "s1", "=", "x", ".", "find", "(", "' '", ",", "l", ")", "# first ws to the right", "s2", "=", "x", ".", "rfind", "(", "' '", ",", "0", ",", "l", ")", "# first ws to the left", "if", "s2", ">", "0", ":", "s", "=", "s2", "if", "s1", "<", "0", "or", "l", "-", "s1", ">", "s2", "-", "l", "else", "s1", "x", "=", "x", "[", ":", "s", "]", "+", "'\\\\n'", "+", "x", "[", "s", "+", "1", ":", "]", "elif", "s1", ">", "0", ":", "x", "=", "x", "[", ":", "s1", "]", "+", "'\\\\n'", "+", "x", "[", "s1", "+", "1", ":", "]", "# Escape HTML reserved characters", "return", "x", ".", "replace", "(", "\"&\"", ",", "\"&amp;\"", ")", ".", "replace", "(", "\"<\"", ",", "\"&lt;\"", ")", ".", "replace", "(", "\">\"", ",", "\"&gt;\"", ")", ".", "replace", "(", "'\"'", ",", "\"&quot;\"", ")" ]

[ "Ensure", "a", "string", "does", "not", "contain", "HTML", "-", "reserved", "characters", "(", "including", "double", "quotes", ")", "Optionally", "also", "insert", "a", "linebreak", "if", "the", "string", "is", "too", "long" ]

[ "def", "expand_envvars", "(", "env", ")", ":", "out_env", "=", "{", "}", "for", "k", ",", "v", "in", "env", ".", "iteritems", "(", ")", ":", "out_env", "[", "k", "]", "=", "Template", "(", "v", ")", ".", "safe_substitute", "(", "env", ")", "# Expand twice to make sure we expand everything we possibly can", "for", "k", ",", "v", "in", "out_env", ".", "items", "(", ")", ":", "out_env", "[", "k", "]", "=", "Template", "(", "v", ")", ".", "safe_substitute", "(", "out_env", ")", "return", "out_env" ]

[ "Expand", "all", "environment", "variables", "in", "an", "environment", "dict" ]

[ "def", "horizontal_path", "(", "size", ")", ":", "width", ",", "height", "=", "size", "return", "(", "(", "(", "x", ",", "y", ")", "for", "x", "in", "range", "(", "width", ")", ")", "for", "y", "in", "range", "(", "height", ")", ")" ]

[ "Creates", "a", "generator", "for", "progressing", "horizontally", "through", "an", "image", ".", ":", "param", "size", ":", "A", "tuple", "(", "width", "height", ")", "of", "the", "image", "size", ":", "return", ":", "A", "generator", "that", "yields", "a", "set", "of", "rows", "through", "the", "image", ".", "Each", "row", "is", "a", "generator", "that", "yields", "pixel", "coordinates", "." ]

[ "def", "getStat", "(", "cls", ",", "obj", ",", "name", ")", ":", "objClass", "=", "type", "(", "obj", ")", "for", "theClass", "in", "objClass", ".", "__mro__", ":", "if", "theClass", "==", "object", ":", "break", "for", "value", "in", "theClass", ".", "__dict__", ".", "values", "(", ")", ":", "if", "isinstance", "(", "value", ",", "Stat", ")", "and", "value", ".", "getName", "(", ")", "==", "name", ":", "return", "value" ]

[ "Gets", "the", "stat", "for", "the", "given", "object", "with", "the", "given", "name", "or", "None", "if", "no", "such", "stat", "exists", "." ]

[ "def", "cmd_fw_manifest_purge", "(", "self", ")", ":", "for", "filepath", "in", "self", ".", "find_manifests", "(", ")", ":", "os", ".", "unlink", "(", "filepath", ")", "self", ".", "manifests_parse", "(", ")" ]

[ "remove", "all", "downloaded", "manifests" ]

[ "def", "get", "(", "self", ",", "key", ",", "prompt_default", "=", "''", ",", "prompt_help", "=", "''", ")", ":", "value", "=", "os", ".", "getenv", "(", "key", ")", "if", "not", "value", ":", "ns", "=", "self", ".", "namespace", "(", "key", ")", "value", "=", "self", ".", "keyring", ".", "get_password", "(", "ns", ",", "key", ")", "else", ":", "ns", "=", "'environ'", "if", "not", "value", ":", "ns", "=", "self", ".", "namespace", "(", "key", ",", "glob", "=", "True", ")", "value", "=", "self", ".", "keyring", ".", "get_password", "(", "ns", ",", "key", ")", "if", "not", "value", ":", "ns", "=", "''", "if", "not", "value", "and", "self", ".", "prompt", ":", "value", "=", "self", ".", "_prompt_for_value", "(", "key", ",", "prompt_default", ",", "prompt_help", ")", "if", "value", ":", "self", ".", "set", "(", "key", ",", "value", ")", "if", "ns", ":", "self", ".", "kns", "[", "key", "]", "=", "ns", "return", "value" ]

[ "Return", "a", "value", "from", "the", "environ", "or", "keyring" ]

[ "def", "html_index", "(", "self", ",", "launch", "=", "False", ",", "showChildren", "=", "False", ")", ":", "self", ".", "makePics", "(", ")", "# ensure all pics are converted", "# generate menu", "html", "=", "'<a href=\"index_splash.html\" target=\"content\">./%s/</a><br>'", "%", "os", ".", "path", ".", "basename", "(", "self", ".", "abfFolder", ")", "for", "ID", "in", "smartSort", "(", "self", ".", "fnamesByCell", ".", "keys", "(", ")", ")", ":", "link", "=", "''", "if", "ID", "+", "\".html\"", "in", "self", ".", "fnames2", ":", "link", "=", "'href=\"%s.html\" target=\"content\"'", "%", "ID", "html", "+=", "(", "'<a %s>%s</a><br>'", "%", "(", "link", ",", "ID", ")", ")", "# show the parent ABF (ID)", "if", "showChildren", ":", "for", "fname", "in", "self", ".", "fnamesByCell", "[", "ID", "]", ":", "thisID", "=", "os", ".", "path", ".", "splitext", "(", "fname", ")", "[", "0", "]", "files2", "=", "[", "x", "for", "x", "in", "self", ".", "fnames2", "if", "x", ".", "startswith", "(", "thisID", ")", "and", "not", "x", ".", "endswith", "(", "\".html\"", ")", "]", "html", "+=", "'<i>%s</i>'", "%", "thisID", "# show the child ABF", "if", "len", "(", "files2", ")", ":", "html", "+=", "' (%s)'", "%", "len", "(", "files2", ")", "# show number of supporting files", "html", "+=", "'<br>'", "html", "+=", "\"<br>\"", "style", ".", "save", "(", "html", ",", "self", ".", "abfFolder2", "+", "\"/index_menu.html\"", ")", "self", ".", "html_index_splash", "(", ")", "# make splash page", "style", ".", "frames", "(", "self", ".", "abfFolder2", "+", "\"/index.html\"", ",", "launch", "=", "launch", ")" ]

[ "generate", "list", "of", "cells", "with", "links", ".", "keep", "this", "simple", ".", "automatically", "generates", "splash", "page", "and", "regnerates", "frames", "." ]

[ "def", "DocbookXslt", "(", "env", ",", "target", ",", "source", "=", "None", ",", "*", "args", ",", "*", "*", "kw", ")", ":", "# Init list of targets/sources", "target", ",", "source", "=", "__extend_targets_sources", "(", "target", ",", "source", ")", "# Init XSL stylesheet", "kw", "[", "'DOCBOOK_XSL'", "]", "=", "kw", ".", "get", "(", "'xsl'", ",", "'transform.xsl'", ")", "# Setup builder", "__builder", "=", "__select_builder", "(", "__lxml_builder", ",", "__libxml2_builder", ",", "__xsltproc_builder", ")", "# Create targets", "result", "=", "[", "]", "for", "t", ",", "s", "in", "zip", "(", "target", ",", "source", ")", ":", "r", "=", "__builder", ".", "__call__", "(", "env", ",", "t", ",", "s", ",", "*", "*", "kw", ")", "env", ".", "Depends", "(", "r", ",", "kw", "[", "'DOCBOOK_XSL'", "]", ")", "result", ".", "extend", "(", "r", ")", "return", "result" ]

[ "A", "pseudo", "-", "Builder", "applying", "a", "simple", "XSL", "transformation", "to", "the", "input", "file", "." ]

[ "def", "_get_corr_stddevs", "(", "C", ",", "tau_ss", ",", "stddev_types", ",", "num_sites", ",", "phi_ss", ",", "NL", "=", "None", ",", "tau_value", "=", "None", ")", ":", "stddevs", "=", "[", "]", "temp_stddev", "=", "phi_ss", "*", "phi_ss", "if", "tau_value", "is", "not", "None", "and", "NL", "is", "not", "None", ":", "temp_stddev", "=", "temp_stddev", "+", "tau_value", "*", "tau_value", "*", "(", "(", "1", "+", "NL", ")", "**", "2", ")", "else", ":", "temp_stddev", "=", "temp_stddev", "+", "C", "[", "tau_ss", "]", "*", "C", "[", "tau_ss", "]", "for", "stddev_type", "in", "stddev_types", ":", "if", "stddev_type", "==", "const", ".", "StdDev", ".", "TOTAL", ":", "stddevs", ".", "append", "(", "np", ".", "sqrt", "(", "temp_stddev", ")", "+", "np", ".", "zeros", "(", "num_sites", ")", ")", "return", "stddevs" ]

[ "Return", "standard", "deviations", "adjusted", "for", "single", "station", "sigma", "as", "the", "total", "standard", "deviation", "-", "as", "proposed", "to", "be", "used", "in", "the", "Swiss", "Hazard", "Model", "[", "2014", "]", "." ]

[ "def", "add_features", "(", "self", ",", "features", ")", ":", "for", "feature", "in", "features", ":", "if", "isinstance", "(", "feature", ",", "basestring", ")", ":", "label", "=", "feature", "value", "=", "None", "else", ":", "label", ",", "value", "=", "feature", "self", ".", "add_feature", "(", "label", ",", "value", ")" ]

[ "Add", "features", "to", "this", "namespace", ".", "features", ":", "An", "iterable", "of", "features", ".", "A", "feature", "may", "be", "either", "1", ")", "A", "VW", "label", "(", "not", "containing", "characters", "from", "escape_dict", ".", "keys", "()", "unless", "escape", "mode", "is", "on", ")", "2", ")", "A", "tuple", "(", "label", "value", ")", "where", "value", "is", "any", "float" ]

[ "def", "findall", "(", "self", ")", ":", "from", "stat", "import", "S_ISREG", ",", "S_ISDIR", ",", "S_ISLNK", "self", ".", "allfiles", "=", "allfiles", "=", "[", "]", "root", "=", "self", ".", "base", "stack", "=", "[", "root", "]", "pop", "=", "stack", ".", "pop", "push", "=", "stack", ".", "append", "while", "stack", ":", "root", "=", "pop", "(", ")", "names", "=", "os", ".", "listdir", "(", "root", ")", "for", "name", "in", "names", ":", "fullname", "=", "os", ".", "path", ".", "join", "(", "root", ",", "name", ")", "# Avoid excess stat calls -- just one will do, thank you!", "stat", "=", "os", ".", "stat", "(", "fullname", ")", "mode", "=", "stat", ".", "st_mode", "if", "S_ISREG", "(", "mode", ")", ":", "allfiles", ".", "append", "(", "fsdecode", "(", "fullname", ")", ")", "elif", "S_ISDIR", "(", "mode", ")", "and", "not", "S_ISLNK", "(", "mode", ")", ":", "push", "(", "fullname", ")" ]

[ "Find", "all", "files", "under", "the", "base", "and", "set", "allfiles", "to", "the", "absolute", "pathnames", "of", "files", "found", "." ]

[ "def", "packageExists", "(", "self", ",", "package", ")", ":", "url", "=", "\"%s/packages\"", "%", "self", ".", "base_url", "params", "=", "{", "\"pattern\"", ":", "package", "}", "response", "=", "requests", ".", "get", "(", "url", ",", "params", "=", "params", ")", "if", "response", ".", "status_code", "!=", "requests", ".", "codes", ".", "ok", ":", "return", "False", "return", "True" ]

[ "Check", "if", "the", "package", "already", "exists" ]

[ "def", "_construct_field_operator_expression_dict", "(", "expression_list", ")", ":", "between_operators", "=", "(", "u'<='", ",", "u'>='", ")", "inverse_operator", "=", "{", "u'>='", ":", "u'<='", ",", "u'<='", ":", "u'>='", "}", "local_field_to_expressions", "=", "{", "}", "remaining_expression_list", "=", "deque", "(", "[", "]", ")", "for", "expression", "in", "expression_list", ":", "if", "all", "(", "(", "isinstance", "(", "expression", ",", "BinaryComposition", ")", ",", "expression", ".", "operator", "in", "between_operators", ",", "isinstance", "(", "expression", ".", "left", ",", "LocalField", ")", "or", "isinstance", "(", "expression", ".", "right", ",", "LocalField", ")", ")", ")", ":", "if", "isinstance", "(", "expression", ".", "right", ",", "LocalField", ")", ":", "new_operator", "=", "inverse_operator", "[", "expression", ".", "operator", "]", "new_expression", "=", "BinaryComposition", "(", "new_operator", ",", "expression", ".", "right", ",", "expression", ".", "left", ")", "else", ":", "new_expression", "=", "expression", "field_name", "=", "new_expression", ".", "left", ".", "field_name", "expressions_dict", "=", "local_field_to_expressions", ".", "setdefault", "(", "field_name", ",", "{", "}", ")", "expressions_dict", ".", "setdefault", "(", "new_expression", ".", "operator", ",", "[", "]", ")", ".", "append", "(", "new_expression", ")", "else", ":", "remaining_expression_list", ".", "append", "(", "expression", ")", "return", "local_field_to_expressions", ",", "remaining_expression_list" ]

[ "Construct", "a", "mapping", "from", "local", "fields", "to", "specified", "operators", "and", "corresponding", "expressions", "." ]

[ "def", "do_json_dupes_for_keys", "(", "self", ",", "params", ")", ":", "try", ":", "Keys", ".", "validate", "(", "params", ".", "keys", ")", "except", "Keys", ".", "Bad", "as", "ex", ":", "self", ".", "show_output", "(", "str", "(", "ex", ")", ")", "return", "path_map", "=", "PathMap", "(", "self", ".", "_zk", ",", "params", ".", "path", ")", "dupes_by_path", "=", "defaultdict", "(", "lambda", ":", "defaultdict", "(", "list", ")", ")", "for", "path", ",", "data", "in", "path_map", ".", "get", "(", ")", ":", "parent", ",", "child", "=", "split", "(", "path", ")", "if", "not", "child", ".", "startswith", "(", "params", ".", "prefix", ")", ":", "continue", "try", ":", "value", "=", "Keys", ".", "value", "(", "json_deserialize", "(", "data", ")", ",", "params", ".", "keys", ")", "dupes_by_path", "[", "parent", "]", "[", "value", "]", ".", "append", "(", "path", ")", "except", "BadJSON", "as", "ex", ":", "if", "params", ".", "report_errors", ":", "self", ".", "show_output", "(", "\"Path %s has bad JSON.\"", ",", "path", ")", "except", "Keys", ".", "Missing", "as", "ex", ":", "if", "params", ".", "report_errors", ":", "self", ".", "show_output", "(", "\"Path %s is missing key %s.\"", ",", "path", ",", "ex", ")", "dupes", "=", "[", "]", "for", "_", ",", "paths_by_value", "in", "dupes_by_path", ".", "items", "(", ")", ":", "for", "_", ",", "paths", "in", "paths_by_value", ".", "items", "(", ")", ":", "if", "len", "(", "paths", ")", ">", "1", ":", "paths", ".", "sort", "(", ")", "paths", "=", "paths", "if", "params", ".", "first", "else", "paths", "[", "1", ":", "]", "for", "path", "in", "paths", ":", "idx", "=", "bisect", ".", "bisect", "(", "dupes", ",", "path", ")", "dupes", ".", "insert", "(", "idx", ",", "path", ")", "for", "dup", "in", "dupes", ":", "self", ".", "show_output", "(", "dup", ")", "# if no dupes were found we call it a failure (i.e.: exit(1) from --run-once)", "if", "len", "(", "dupes", ")", "==", "0", ":", "return", "False" ]

[ "\\", "x1b", "[", "1mNAME", "\\", "x1b", "[", "0m", "json_duples_for_keys", "-", "Gets", "the", "duplicate", "znodes", "for", "the", "given", "keys" ]

[ "def", "resolve_schema_in_request_body", "(", "self", ",", "request_body", ")", ":", "content", "=", "request_body", "[", "\"content\"", "]", "for", "content_type", "in", "content", ":", "schema", "=", "content", "[", "content_type", "]", "[", "\"schema\"", "]", "content", "[", "content_type", "]", "[", "\"schema\"", "]", "=", "self", ".", "openapi", ".", "resolve_schema_dict", "(", "schema", ")" ]

[ "Function", "to", "resolve", "a", "schema", "in", "a", "requestBody", "object", "-", "modifies", "then", "response", "dict", "to", "convert", "Marshmallow", "Schema", "object", "or", "class", "into", "dict" ]

[ "def", "_reversedict", "(", "d", ")", ":", "return", "dict", "(", "list", "(", "zip", "(", "list", "(", "d", ".", "values", "(", ")", ")", ",", "list", "(", "d", ".", "keys", "(", ")", ")", ")", ")", ")" ]

[ "Internal", "helper", "for", "generating", "reverse", "mappings", ";", "given", "a", "dictionary", "returns", "a", "new", "dictionary", "with", "keys", "and", "values", "swapped", "." ]

[ "def", "map_set_properties", "(", "m", ":", "tcod", ".", "map", ".", "Map", ",", "x", ":", "int", ",", "y", ":", "int", ",", "isTrans", ":", "bool", ",", "isWalk", ":", "bool", ")", "->", "None", ":", "lib", ".", "TCOD_map_set_properties", "(", "m", ".", "map_c", ",", "x", ",", "y", ",", "isTrans", ",", "isWalk", ")" ]

[ "Set", "the", "properties", "of", "a", "single", "cell", "." ]

[ "def", "_convert_markup_images", "(", "self", ",", "soup", ")", ":", "# 6. Replace <img> assets with actual image contents", "images", "=", "[", "image", "for", "image", "in", "soup", ".", "find_all", "(", "'img'", ")", "if", "image", ".", "attrs", ".", "get", "(", "'assetid'", ")", "is", "not", "None", "]", "if", "not", "images", ":", "return", "# Get assetid attribute from all images", "asset_ids", "=", "[", "image", ".", "attrs", ".", "get", "(", "'assetid'", ")", "for", "image", "in", "images", "]", "self", ".", "_asset_retriever", "(", "asset_ids", ")", "for", "image", "in", "images", ":", "# Encode each image using base64", "asset", "=", "self", ".", "_asset_retriever", "[", "image", "[", "'assetid'", "]", "]", "if", "asset", ".", "data", "is", "not", "None", ":", "encoded64", "=", "base64", ".", "b64encode", "(", "asset", ".", "data", ")", ".", "decode", "(", ")", "image", "[", "'src'", "]", "=", "'data:%s;base64,%s'", "%", "(", "asset", ".", "content_type", ",", "encoded64", ")" ]

[ "Convert", "images", "of", "instructions", "markup", ".", "Images", "are", "downloaded", "base64", "-", "encoded", "and", "inserted", "into", "<img", ">", "tags", "." ]

[ "def", "check_str", "(", "obj", ")", ":", "if", "isinstance", "(", "obj", ",", "str", ")", ":", "return", "obj", "if", "isinstance", "(", "obj", ",", "float", ")", ":", "return", "str", "(", "int", "(", "obj", ")", ")", "else", ":", "return", "str", "(", "obj", ")" ]

[ "Returns", "a", "string", "for", "various", "input", "types" ]

[ "def", "sigmoidal", "(", "arr", ",", "contrast", ",", "bias", ")", ":", "if", "(", "arr", ".", "max", "(", ")", ">", "1.0", "+", "epsilon", ")", "or", "(", "arr", ".", "min", "(", ")", "<", "0", "-", "epsilon", ")", ":", "raise", "ValueError", "(", "\"Input array must have float values between 0 and 1\"", ")", "if", "(", "bias", ">", "1.0", "+", "epsilon", ")", "or", "(", "bias", "<", "0", "-", "epsilon", ")", ":", "raise", "ValueError", "(", "\"bias must be a scalar float between 0 and 1\"", ")", "alpha", ",", "beta", "=", "bias", ",", "contrast", "# We use the names a and b to match documentation.", "if", "alpha", "==", "0", ":", "alpha", "=", "epsilon", "if", "beta", "==", "0", ":", "return", "arr", "np", ".", "seterr", "(", "divide", "=", "\"ignore\"", ",", "invalid", "=", "\"ignore\"", ")", "if", "beta", ">", "0", ":", "numerator", "=", "1", "/", "(", "1", "+", "np", ".", "exp", "(", "beta", "*", "(", "alpha", "-", "arr", ")", ")", ")", "-", "1", "/", "(", "1", "+", "np", ".", "exp", "(", "beta", "*", "alpha", ")", ")", "denominator", "=", "1", "/", "(", "1", "+", "np", ".", "exp", "(", "beta", "*", "(", "alpha", "-", "1", ")", ")", ")", "-", "1", "/", "(", "1", "+", "np", ".", "exp", "(", "beta", "*", "alpha", ")", ")", "output", "=", "numerator", "/", "denominator", "else", ":", "# Inverse sigmoidal function:", "# todo: account for 0s", "# todo: formatting ;)", "output", "=", "(", "(", "beta", "*", "alpha", ")", "-", "np", ".", "log", "(", "(", "1", "/", "(", "(", "arr", "/", "(", "1", "+", "np", ".", "exp", "(", "beta", "*", "alpha", "-", "beta", ")", ")", ")", "-", "(", "arr", "/", "(", "1", "+", "np", ".", "exp", "(", "beta", "*", "alpha", ")", ")", ")", "+", "(", "1", "/", "(", "1", "+", "np", ".", "exp", "(", "beta", "*", "alpha", ")", ")", ")", ")", ")", "-", "1", ")", ")", "/", "beta", "return", "output" ]

[ "r", "Sigmoidal", "contrast", "is", "type", "of", "contrast", "control", "that", "adjusts", "the", "contrast", "without", "saturating", "highlights", "or", "shadows", ".", "It", "allows", "control", "over", "two", "factors", ":", "the", "contrast", "range", "from", "light", "to", "dark", "and", "where", "the", "middle", "value", "of", "the", "mid", "-", "tones", "falls", ".", "The", "result", "is", "a", "non", "-", "linear", "and", "smooth", "contrast", "change", "." ]

[ "def", "set_raw_data", "(", "self", ",", "raw_data", ")", ":", "#pre-parsed data should exist\r", "assert", "(", "self", ".", "__hid_object", ".", "is_opened", "(", ")", ")", "#valid length\r", "if", "len", "(", "raw_data", ")", "!=", "self", ".", "__raw_report_size", ":", "raise", "HIDError", "(", "\"Report size has to be %d elements (bytes)\"", "%", "self", ".", "__raw_report_size", ")", "# copy to internal storage\r", "self", ".", "__alloc_raw_data", "(", "raw_data", ")", "if", "not", "self", ".", "__usage_data_list", ":", "# create HIDP_DATA buffer\r", "max_items", "=", "hid_dll", ".", "HidP_MaxDataListLength", "(", "self", ".", "__report_kind", ",", "self", ".", "__hid_object", ".", "ptr_preparsed_data", ")", "data_list_type", "=", "winapi", ".", "HIDP_DATA", "*", "max_items", "self", ".", "__usage_data_list", "=", "data_list_type", "(", ")", "#reference HIDP_DATA buffer\r", "data_list", "=", "self", ".", "__usage_data_list", "data_len", "=", "c_ulong", "(", "len", "(", "data_list", ")", ")", "#reset old values\r", "for", "item", "in", "self", ".", "values", "(", ")", ":", "if", "item", ".", "is_value_array", "(", ")", ":", "item", ".", "value", "=", "[", "0", ",", "]", "*", "len", "(", "item", ")", "else", ":", "item", ".", "value", "=", "0", "#ready, parse raw data\r", "HidStatus", "(", "hid_dll", ".", "HidP_GetData", "(", "self", ".", "__report_kind", ",", "byref", "(", "data_list", ")", ",", "byref", "(", "data_len", ")", ",", "self", ".", "__hid_object", ".", "ptr_preparsed_data", ",", "byref", "(", "self", ".", "__raw_data", ")", ",", "len", "(", "self", ".", "__raw_data", ")", ")", ")", "#set values on internal report item objects\r", "for", "idx", "in", "range", "(", "data_len", ".", "value", ")", ":", "value_item", "=", "data_list", "[", "idx", "]", "report_item", "=", "self", ".", "__idx_items", ".", "get", "(", "value_item", ".", "data_index", ")", "if", "not", "report_item", ":", "# This is not expected to happen\r", "continue", "if", "report_item", ".", "is_value", "(", ")", ":", "report_item", ".", "value", "=", "value_item", ".", "value", ".", "raw_value", "elif", "report_item", ".", "is_button", "(", ")", ":", "report_item", ".", "value", "=", "value_item", ".", "value", ".", "on", "else", ":", "pass", "# HID API should give us either, at least one of 'em\r", "#get values of array items\r", "for", "item", "in", "self", ".", "__value_array_items", ":", "#ask hid API to parse\r", "HidStatus", "(", "hid_dll", ".", "HidP_GetUsageValueArray", "(", "self", ".", "__report_kind", ",", "item", ".", "page_id", ",", "0", ",", "#link collection\r", "item", ".", "usage_id", ",", "#short usage\r", "byref", "(", "item", ".", "value_array", ")", ",", "#output data (c_ubyte storage)\r", "len", "(", "item", ".", "value_array", ")", ",", "self", ".", "__hid_object", ".", "ptr_preparsed_data", ",", "byref", "(", "self", ".", "__raw_data", ")", ",", "len", "(", "self", ".", "__raw_data", ")", ")", ")" ]

[ "Set", "usage", "values", "based", "on", "given", "raw", "data", "item", "[", "0", "]", "is", "report_id", "length", "should", "match", "raw_data_length", "value", "best", "performance", "if", "raw_data", "is", "c_ubyte", "ctypes", "array", "object", "type" ]

[ "def", "grating_coupler_period", "(", "wavelength", ",", "n_eff", ",", "n_clad", ",", "incidence_angle_deg", ",", "diffration_order", "=", "1", ")", ":", "k0", "=", "2.", "*", "np", ".", "pi", "/", "wavelength", "beta", "=", "n_eff", ".", "real", "*", "k0", "n_inc", "=", "n_clad", "grating_period", "=", "(", "2.", "*", "np", ".", "pi", "*", "diffration_order", ")", "/", "(", "beta", "-", "k0", "*", "n_inc", "*", "np", ".", "sin", "(", "np", ".", "radians", "(", "incidence_angle_deg", ")", ")", ")", "return", "grating_period" ]

[ "Calculate", "the", "period", "needed", "for", "a", "grating", "coupler", "." ]

[ "def", "compile_python_files", "(", "self", ",", "dir", ")", ":", "args", "=", "[", "self", ".", "ctx", ".", "hostpython", "]", "if", "self", ".", "ctx", ".", "python_recipe", ".", "name", "==", "'python3'", ":", "args", "+=", "[", "'-OO'", ",", "'-m'", ",", "'compileall'", ",", "'-b'", ",", "'-f'", ",", "dir", "]", "else", ":", "args", "+=", "[", "'-OO'", ",", "'-m'", ",", "'compileall'", ",", "'-f'", ",", "dir", "]", "subprocess", ".", "call", "(", "args", ")" ]

[ "Compile", "the", "python", "files", "(", "recursively", ")", "for", "the", "python", "files", "inside", "a", "given", "folder", "." ]

[ "def", "convert", "(", "self", ",", "path", ",", "version", ",", "target", "=", "None", ")", ":", "#Get the template and values out of the XML input file and", "#write them in the format of the keywordless file.", "values", ",", "template", "=", "self", ".", "parse", "(", "path", ")", "lines", "=", "template", ".", "write", "(", "values", ",", "version", ")", "#Finally, write the lines to the correct path.", "if", "target", "is", "None", ":", "target", "=", "os", ".", "path", ".", "join", "(", "os", ".", "path", ".", "dirname", "(", "path", ")", ",", "template", ".", "name", ")", "with", "open", "(", "os", ".", "path", ".", "expanduser", "(", "target", ")", ",", "'w'", ")", "as", "f", ":", "f", ".", "write", "(", "\"\\n\"", ".", "join", "(", "lines", ")", ")" ]

[ "Converts", "the", "specified", "file", "using", "the", "relevant", "template", "." ]

[ "def", "setup", "(", ")", ":", "print", "(", "\"Simple drive\"", ")", "board", ".", "set_pin_mode", "(", "L_CTRL_1", ",", "Constants", ".", "OUTPUT", ")", "board", ".", "set_pin_mode", "(", "L_CTRL_2", ",", "Constants", ".", "OUTPUT", ")", "board", ".", "set_pin_mode", "(", "PWM_L", ",", "Constants", ".", "PWM", ")", "board", ".", "set_pin_mode", "(", "R_CTRL_1", ",", "Constants", ".", "OUTPUT", ")", "board", ".", "set_pin_mode", "(", "R_CTRL_2", ",", "Constants", ".", "OUTPUT", ")", "board", ".", "set_pin_mode", "(", "PWM_R", ",", "Constants", ".", "PWM", ")" ]

[ "Setup", "pins" ]

[ "def", "_calculate_conversion", "(", "hdr", ")", ":", "discardbits", "=", "hdr", "[", "'discardbits'", "]", "n_chan", "=", "hdr", "[", "'num_channels'", "]", "if", "hdr", "[", "'headbox_type'", "]", "[", "0", "]", "in", "(", "1", ",", "3", ")", ":", "# all channels", "factor", "=", "ones", "(", "(", "n_chan", ")", ")", "*", "(", "8711.", "/", "(", "2", "**", "21", "-", "0.5", ")", ")", "*", "2", "**", "discardbits", "elif", "hdr", "[", "'headbox_type'", "]", "[", "0", "]", "==", "4", ":", "# 0 - 23", "ch1", "=", "ones", "(", "(", "24", ")", ")", "*", "(", "8711.", "/", "(", "2", "**", "21", "-", "0.5", ")", ")", "*", "2", "**", "discardbits", "# 24 - 27", "ch2", "=", "ones", "(", "(", "4", ")", ")", "*", "(", "(", "5000000.", "/", "(", "2", "**", "10", "-", "0.5", ")", ")", "/", "(", "2", "**", "6", ")", ")", "*", "2", "**", "discardbits", "factor", "=", "concatenate", "(", "(", "ch1", ",", "ch2", ")", ")", "elif", "hdr", "[", "'headbox_type'", "]", "[", "0", "]", "==", "6", ":", "# 0 - 31", "ch1", "=", "ones", "(", "(", "32", ")", ")", "*", "(", "8711.", "/", "(", "2", "**", "21", "-", "0.5", ")", ")", "*", "2", "**", "discardbits", "# 32 - 35", "ch2", "=", "ones", "(", "(", "4", ")", ")", "*", "(", "(", "5000000.", "/", "(", "2", "**", "10", "-", "0.5", ")", ")", "/", "(", "2", "**", "6", ")", ")", "*", "2", "**", "discardbits", "factor", "=", "concatenate", "(", "(", "ch1", ",", "ch2", ")", ")", "elif", "hdr", "[", "'headbox_type'", "]", "[", "0", "]", "==", "8", ":", "# 0 - 24", "ch1", "=", "ones", "(", "(", "25", ")", ")", "*", "(", "8711.", "/", "(", "(", "2", "**", "21", ")", "-", "0.5", ")", ")", "*", "2", "**", "discardbits", "# 25 - 26", "ch2", "=", "ones", "(", "(", "2", ")", ")", "*", "(", "1", "/", "(", "2", "**", "6", ")", ")", "*", "2", "**", "discardbits", "factor", "=", "concatenate", "(", "(", "ch1", ",", "ch2", ")", ")", "elif", "hdr", "[", "'headbox_type'", "]", "[", "0", "]", "==", "9", ":", "# 0 - 32", "ch1", "=", "ones", "(", "(", "33", ")", ")", "*", "(", "8711.", "/", "(", "(", "2", "**", "21", ")", "-", "0.5", ")", ")", "*", "2", "**", "discardbits", "# 33 - 34", "ch2", "=", "ones", "(", "(", "2", ")", ")", "*", "(", "1", "/", "(", "2", "**", "6", ")", ")", "*", "2", "**", "discardbits", "factor", "=", "concatenate", "(", "(", "ch1", ",", "ch2", ")", ")", "elif", "hdr", "[", "'headbox_type'", "]", "[", "0", "]", "==", "14", ":", "# 0 - 37", "ch1", "=", "ones", "(", "(", "38", ")", ")", "*", "(", "8711.", "/", "(", "(", "2", "**", "21", ")", "-", "0.5", ")", ")", "*", "2", "**", "discardbits", "# 38 - 47", "ch2", "=", "ones", "(", "(", "10", ")", ")", "*", "(", "(", "10800000", "/", "65536", ")", "/", "(", "2", "**", "6", ")", ")", "*", "2", "**", "discardbits", "# 48-49", "ch3", "=", "ones", "(", "(", "2", ")", ")", "*", "(", "1", "/", "(", "2", "**", "6", ")", ")", "*", "2", "**", "discardbits", "factor", "=", "concatenate", "(", "(", "ch1", ",", "ch2", ",", "ch3", ")", ")", "elif", "hdr", "[", "'headbox_type'", "]", "[", "0", "]", "==", "15", ":", "# 0 - 23", "ch1", "=", "ones", "(", "(", "24", ")", ")", "*", "(", "8711.", "/", "(", "(", "2", "**", "21", ")", "-", "0.5", ")", ")", "*", "2", "**", "discardbits", "# 24 - 27 (as above)", "ch2", "=", "ones", "(", "(", "4", ")", ")", "*", "(", "8711.", "/", "(", "(", "2", "**", "21", ")", "-", "0.5", ")", ")", "*", "2", "**", "discardbits", "# 28 - 31 (note 10000000 instead of 10800000)", "ch3", "=", "ones", "(", "(", "4", ")", ")", "*", "(", "(", "10000000", "/", "65536", ")", "/", "(", "2", "**", "6", ")", ")", "*", "2", "**", "discardbits", "# 32-33", "ch4", "=", "ones", "(", "(", "2", ")", ")", "*", "(", "1", "/", "(", "2", "**", "6", ")", ")", "*", "2", "**", "discardbits", "factor", "=", "concatenate", "(", "(", "ch1", ",", "ch2", ",", "ch3", ",", "ch4", ")", ")", "elif", "hdr", "[", "'headbox_type'", "]", "[", "0", "]", "==", "17", ":", "# 0 - 39", "ch1", "=", "ones", "(", "(", "40", ")", ")", "*", "(", "8711.", "/", "(", "(", "2", "**", "21", ")", "-", "0.5", ")", ")", "*", "2", "**", "discardbits", "# 40 - 43", "ch2", "=", "ones", "(", "(", "4", ")", ")", "*", "(", "(", "10800000", "/", "65536", ")", "/", "(", "2", "**", "6", ")", ")", "*", "2", "**", "discardbits", "# 44 - 45", "ch3", "=", "ones", "(", "(", "2", ")", ")", "*", "(", "1", "/", "(", "2", "**", "6", ")", ")", "*", "2", "**", "discardbits", "factor", "=", "concatenate", "(", "(", "ch1", ",", "ch2", ",", "ch3", ")", ")", "elif", "hdr", "[", "'headbox_type'", "]", "[", "0", "]", "==", "19", ":", "# all channels", "factor", "=", "ones", "(", "(", "n_chan", ")", ")", "*", "(", "8711.", "/", "(", "(", "2", "**", "21", ")", "-", "0.5", ")", ")", "*", "2", "**", "discardbits", "elif", "hdr", "[", "'headbox_type'", "]", "[", "0", "]", "==", "21", ":", "# 0 - 127", "ch1", "=", "ones", "(", "(", "128", ")", ")", "*", "(", "8711.", "/", "(", "(", "2", "**", "21", ")", "-", "0.5", ")", ")", "*", "2", "**", "discardbits", "# 128 - 129", "ch2", "=", "ones", "(", "(", "2", ")", ")", "*", "(", "1", "/", "(", "2", "**", "6", ")", ")", "*", "2", "**", "discardbits", "# 130 - 255", "ch3", "=", "ones", "(", "(", "126", ")", ")", "*", "(", "8711.", "/", "(", "(", "2", "**", "21", ")", "-", "0.5", ")", ")", "*", "2", "**", "discardbits", "factor", "=", "concatenate", "(", "(", "ch1", ",", "ch2", ",", "ch3", ")", ")", "elif", "hdr", "[", "'headbox_type'", "]", "[", "0", "]", "==", "22", ":", "# 0 - 31", "ch1", "=", "ones", "(", "(", "32", ")", ")", "*", "(", "8711.", "/", "(", "(", "2", "**", "21", ")", "-", "0.5", ")", ")", "*", "2", "**", "discardbits", "# 32 - 39", "ch2", "=", "ones", "(", "(", "8", ")", ")", "*", "(", "(", "10800000.", "/", "65536.", ")", "/", "(", "2", "**", "6", ")", ")", "*", "2", "**", "discardbits", "# 40 - 41", "ch3", "=", "ones", "(", "(", "2", ")", ")", "*", "(", "1", "/", "(", "2", "**", "6", ")", ")", "*", "2", "**", "discardbits", "# 42", "ch4", "=", "ones", "(", "(", "1", ")", ")", "*", "(", "(", "10800000.", "/", "65536.", ")", "/", "(", "2", "**", "6", ")", ")", "*", "2", "**", "discardbits", "factor", "=", "concatenate", "(", "(", "ch1", ",", "ch2", ",", "ch3", ",", "ch4", ")", ")", "elif", "hdr", "[", "'headbox_type'", "]", "[", "0", "]", "==", "23", ":", "# 0 - 31", "ch1", "=", "ones", "(", "(", "32", ")", ")", "*", "(", "8711.", "/", "(", "(", "2", "**", "21", ")", "-", "0.5", ")", ")", "*", "2", "**", "discardbits", "# 32 - 35", "ch2", "=", "ones", "(", "(", "4", ")", ")", "*", "(", "(", "10800000.", "/", "65536.", ")", "/", "(", "2", "**", "6", ")", ")", "*", "2", "**", "discardbits", "# 36 - 37", "ch3", "=", "ones", "(", "(", "2", ")", ")", "*", "(", "1", "/", "(", "2", "**", "6", ")", ")", "*", "2", "**", "discardbits", "# 38", "ch4", "=", "ones", "(", "(", "1", ")", ")", "*", "(", "(", "10800000.", "/", "65536.", ")", "/", "(", "2", "**", "6", ")", ")", "*", "2", "**", "discardbits", "factor", "=", "concatenate", "(", "(", "ch1", ",", "ch2", ",", "ch3", ",", "ch4", ")", ")", "else", ":", "raise", "NotImplementedError", "(", "'Implement conversion factor for headbox '", "+", "str", "(", "hdr", "[", "'headbox_type'", "]", "[", "0", "]", ")", ")", "return", "factor", "[", ":", "n_chan", "]" ]

[ "Calculate", "the", "conversion", "factor", "." ]

[ "def", "Property", "(", "self", ",", "ObjectType", ",", "ObjectId", ",", "PropName", ",", "Set", "=", "None", ")", ":", "return", "self", ".", "_Property", "(", "ObjectType", ",", "ObjectId", ",", "PropName", ",", "Set", ")" ]

[ "Queries", "/", "sets", "the", "properties", "of", "an", "object", "." ]