Datasets:

---

kejian

/

codesearchnet-python-raw

like 1

[ "def", "getAddressBinding", "(", "self", ")", ":", "for", "item", "in", "self", ".", "extensions", ":", "if", "isinstance", "(", "item", ",", "SoapAddressBinding", ")", "or", "isinstance", "(", "item", ",", "HttpAddressBinding", ")", ":", "return", "item", "raise", "WSDLError", "(", "'No address binding found in port.'", ")" ]

[ "A", "convenience", "method", "to", "obtain", "the", "extension", "element", "used", "as", "the", "address", "binding", "for", "the", "port", "." ]

[ "def", "vlog", "(", "self", ",", "msg", ",", "*", "args", ")", ":", "if", "self", ".", "verbose", ":", "self", ".", "log", "(", "msg", ",", "*", "args", ")" ]

[ "Logs", "a", "message", "to", "stderr", "only", "if", "verbose", "is", "enabled", "." ]

[ "def", "after_run", "(", "self", ",", "remote_file_data", ")", ":", "if", "self", ".", "file_upload_post_processor", ":", "self", ".", "file_upload_post_processor", ".", "run", "(", "self", ".", "settings", ".", "data_service", ",", "remote_file_data", ")", "remote_file_id", "=", "remote_file_data", "[", "'id'", "]", "self", ".", "settings", ".", "watcher", ".", "transferring_item", "(", "self", ".", "local_file", ")", "self", ".", "local_file", ".", "set_remote_id_after_send", "(", "remote_file_id", ")" ]

[ "Save", "uuid", "of", "file", "to", "our", "LocalFile", ":", "param", "remote_file_data", ":", "dict", ":", "DukeDS", "file", "data" ]

[ "def", "get_root", "(", "self", ")", ":", "return", "get_result_class", "(", "self", ".", "__class__", ")", ".", "objects", ".", "get", "(", "path", "=", "self", ".", "path", "[", "0", ":", "self", ".", "steplen", "]", ")" ]

[ ":", "returns", ":", "the", "root", "node", "for", "the", "current", "node", "object", "." ]

[ "def", "add_keywords", "(", "opts", ")", ":", "dialect", "=", "opts", ".", "dialect", "keywords", "=", "collections", ".", "defaultdict", "(", "int", ")", "two_spacers", "=", "[", "]", "two_armed", "=", "IF_LIKE", "local_binders", "=", "[", "]", "if", "dialect", "==", "'lisp'", ":", "# Lisp", "two_spacers", "=", "LISP_KEYWORDS", "two_armed", "+=", "[", "'multiple-value-bind'", ",", "'destructuring-bind'", ",", "'do'", ",", "'do*'", "]", "local_binders", "+=", "[", "'flet'", ",", "'macrolet'", ",", "'labels'", "]", "elif", "dialect", "==", "'scheme'", ":", "# Scheme", "two_spacers", "=", "SCHEME_KEYWORDS", "two_armed", "+=", "[", "'with-slots'", ",", "'do'", ",", "'do*'", "]", "local_binders", "+=", "[", "]", "elif", "dialect", "==", "'clojure'", ":", "# Clojure", "two_spacers", "=", "CLOJURE_KEYWORDS", "two_armed", "+=", "[", "]", "local_binders", "+=", "[", "'letfn'", "]", "elif", "dialect", "==", "'newlisp'", ":", "# newLISP", "two_spacers", "=", "NEWLISP_KEYWORDS", "two_armed", "+=", "[", "]", "local_binders", "+=", "[", "]", "elif", "dialect", "==", "'all'", ":", "two_spacers", "=", "LISP_KEYWORDS", "+", "SCHEME_KEYWORDS", "+", "CLOJURE_KEYWORDS", "+", "NEWLISP_KEYWORDS", "keywords", "=", "assign_indent_numbers", "(", "two_spacers", ",", "KEYWORD1", ",", "keywords", ")", "keywords", "=", "assign_indent_numbers", "(", "two_armed", ",", "KEYWORD2", ",", "keywords", ")", "keywords", "=", "assign_indent_numbers", "(", "local_binders", ",", "KEYWORD4", ",", "keywords", ")", "if", "opts", ".", "read_rc", ":", "rc_keywords", "=", "parse_rc_json", "(", ")", "keywords", ".", "update", "(", "rc_keywords", "[", "dialect", "]", ")", "return", "keywords" ]

[ "add_keywords", "(", "dialect", ":", "str", ")", "-", ">", "[", "str", "str", "]" ]

[ "def", "_add_missing_schema_attributes", "(", "self", ")", ":", "for", "attr", "in", "[", "attr", "for", "attr", "in", "dir", "(", "self", ")", "if", "not", "attr", ".", "startswith", "(", "'__'", ")", "]", ":", "attr_val", "=", "getattr", "(", "self", ",", "attr", ")", "if", "isinstance", "(", "getattr", "(", "self", ",", "attr", ")", ",", "SchemaItem", ")", "and", "attr", "not", "in", "self", ".", "_attributes", ":", "self", ".", "_attributes", ".", "append", "(", "attr", ")" ]

[ "Adds", "any", "missed", "schema", "attributes", "to", "the", "_attributes", "list" ]

[ "def", "log", "(", "self", ",", "logfile", "=", "None", ")", ":", "if", "logfile", "is", "None", ":", "logfile", "=", "sys", ".", "stderr", "tb", "=", "self", ".", "plaintext", ".", "encode", "(", "'utf-8'", ",", "'replace'", ")", ".", "rstrip", "(", ")", "+", "'\\n'", "logfile", ".", "write", "(", "tb", ")" ]

[ "Log", "the", "ASCII", "traceback", "into", "a", "file", "object", "." ]

[ "def", "field_values", "(", "self", ")", ":", "if", "self", ".", "_field_values", "is", "None", ":", "self", ".", "_field_values", "=", "FieldValueList", "(", "self", ".", "_version", ",", "assistant_sid", "=", "self", ".", "_solution", "[", "'assistant_sid'", "]", ",", "field_type_sid", "=", "self", ".", "_solution", "[", "'sid'", "]", ",", ")", "return", "self", ".", "_field_values" ]

[ "Access", "the", "field_values" ]

[ "def", "set_identities", "(", "self", ",", "identities", ")", ":", "for", "identity", "in", "self", ".", "identities", ":", "identity", ".", "remove", "(", ")", "for", "identity", "in", "identities", ":", "try", ":", "self", ".", "add_identity", "(", "identity", ".", "name", ",", "identity", ".", "category", ",", "identity", ".", "type", ")", "except", "AttributeError", ":", "self", ".", "add_identity", "(", "*", "identity", ")" ]

[ "Set", "identities", "in", "the", "disco#info", "object", "." ]

[ "def", "_tf_batch_map_offsets", "(", "self", ",", "inputs", ",", "offsets", ",", "grid_offset", ")", ":", "input_shape", "=", "inputs", ".", "get_shape", "(", ")", "batch_size", "=", "tf", ".", "shape", "(", "inputs", ")", "[", "0", "]", "kernel_n", "=", "int", "(", "int", "(", "offsets", ".", "get_shape", "(", ")", "[", "3", "]", ")", "/", "2", ")", "input_h", "=", "input_shape", "[", "1", "]", "input_w", "=", "input_shape", "[", "2", "]", "channel", "=", "input_shape", "[", "3", "]", "# inputs (b, h, w, c) --> (b*c, h, w)", "inputs", "=", "self", ".", "_to_bc_h_w", "(", "inputs", ",", "input_shape", ")", "# offsets (b, h, w, 2*n) --> (b, h, w, n, 2)", "offsets", "=", "tf", ".", "reshape", "(", "offsets", ",", "(", "batch_size", ",", "input_h", ",", "input_w", ",", "kernel_n", ",", "2", ")", ")", "# offsets (b, h, w, n, 2) --> (b*c, h, w, n, 2)", "# offsets = tf.tile(offsets, [channel, 1, 1, 1, 1])", "coords", "=", "tf", ".", "expand_dims", "(", "grid_offset", ",", "0", ")", "# grid_offset --> (1, h, w, n, 2)", "coords", "=", "tf", ".", "tile", "(", "coords", ",", "[", "batch_size", ",", "1", ",", "1", ",", "1", ",", "1", "]", ")", "+", "offsets", "# grid_offset --> (b, h, w, n, 2)", "# clip out of bound", "coords", "=", "tf", ".", "stack", "(", "[", "tf", ".", "clip_by_value", "(", "coords", "[", ":", ",", ":", ",", ":", ",", ":", ",", "0", "]", ",", "0.0", ",", "tf", ".", "cast", "(", "input_h", "-", "1", ",", "'float32'", ")", ")", ",", "tf", ".", "clip_by_value", "(", "coords", "[", ":", ",", ":", ",", ":", ",", ":", ",", "1", "]", ",", "0.0", ",", "tf", ".", "cast", "(", "input_w", "-", "1", ",", "'float32'", ")", ")", "]", ",", "axis", "=", "-", "1", ")", "coords", "=", "tf", ".", "tile", "(", "coords", ",", "[", "channel", ",", "1", ",", "1", ",", "1", ",", "1", "]", ")", "mapped_vals", "=", "self", ".", "_tf_batch_map_coordinates", "(", "inputs", ",", "coords", ")", "# (b*c, h, w, n) --> (b, h, w, n, c)", "mapped_vals", "=", "self", ".", "_to_b_h_w_n_c", "(", "mapped_vals", ",", "[", "batch_size", ",", "input_h", ",", "input_w", ",", "kernel_n", ",", "channel", "]", ")", "return", "mapped_vals" ]

[ "Batch", "map", "offsets", "into", "input" ]

[ "def", "parse_article", "(", "generator", ",", "metadata", ")", ":", "if", "'event-start'", "not", "in", "metadata", ":", "return", "dtstart", "=", "parse_tstamp", "(", "metadata", ",", "'event-start'", ")", "if", "'event-end'", "in", "metadata", ":", "dtend", "=", "parse_tstamp", "(", "metadata", ",", "'event-end'", ")", "elif", "'event-duration'", "in", "metadata", ":", "dtdelta", "=", "parse_timedelta", "(", "metadata", ")", "dtend", "=", "dtstart", "+", "dtdelta", "else", ":", "msg", "=", "\"Either 'event-end' or 'event-duration' must be\"", "+", "\" speciefied in the event named '%s'\"", "%", "metadata", "[", "'title'", "]", "log", ".", "error", "(", "msg", ")", "raise", "ValueError", "(", "msg", ")", "events", ".", "append", "(", "Event", "(", "dtstart", ",", "dtend", ",", "metadata", ")", ")" ]

[ "Collect", "articles", "metadata", "to", "be", "used", "for", "building", "the", "event", "calendar" ]

[ "def", "_send_segment", "(", "self", ")", ":", "segment", "=", "self", ".", "current_segment", "(", ")", "if", "not", "segment", ":", "return", "if", "segment", ".", "sampled", ":", "self", ".", "emitter", ".", "send_entity", "(", "segment", ")", "self", ".", "clear_trace_entities", "(", ")" ]

[ "Send", "the", "current", "segment", "to", "X", "-", "Ray", "daemon", "if", "it", "is", "present", "and", "sampled", "then", "clean", "up", "context", "storage", ".", "The", "emitter", "will", "handle", "failures", "." ]

[ "def", "do_keygen", "(", "args", ")", ":", "if", "args", ".", "key_name", "is", "not", "None", ":", "key_name", "=", "args", ".", "key_name", "else", ":", "key_name", "=", "'validator'", "key_dir", "=", "get_key_dir", "(", ")", "if", "not", "os", ".", "path", ".", "exists", "(", "key_dir", ")", ":", "raise", "CliException", "(", "\"Key directory does not exist: {}\"", ".", "format", "(", "key_dir", ")", ")", "priv_filename", "=", "os", ".", "path", ".", "join", "(", "key_dir", ",", "key_name", "+", "'.priv'", ")", "pub_filename", "=", "os", ".", "path", ".", "join", "(", "key_dir", ",", "key_name", "+", "'.pub'", ")", "if", "not", "args", ".", "force", ":", "file_exists", "=", "False", "for", "filename", "in", "[", "priv_filename", ",", "pub_filename", "]", ":", "if", "os", ".", "path", ".", "exists", "(", "filename", ")", ":", "file_exists", "=", "True", "print", "(", "'file exists: {}'", ".", "format", "(", "filename", ")", ",", "file", "=", "sys", ".", "stderr", ")", "if", "file_exists", ":", "raise", "CliException", "(", "'files exist, rerun with --force to overwrite existing files'", ")", "context", "=", "create_context", "(", "'secp256k1'", ")", "private_key", "=", "context", ".", "new_random_private_key", "(", ")", "public_key", "=", "context", ".", "get_public_key", "(", "private_key", ")", "try", ":", "priv_exists", "=", "os", ".", "path", ".", "exists", "(", "priv_filename", ")", "with", "open", "(", "priv_filename", ",", "'w'", ")", "as", "priv_fd", ":", "if", "not", "args", ".", "quiet", ":", "if", "priv_exists", ":", "print", "(", "'overwriting file: {}'", ".", "format", "(", "priv_filename", ")", ")", "else", ":", "print", "(", "'writing file: {}'", ".", "format", "(", "priv_filename", ")", ")", "priv_fd", ".", "write", "(", "private_key", ".", "as_hex", "(", ")", ")", "priv_fd", ".", "write", "(", "'\\n'", ")", "# Get the uid and gid of the key directory", "keydir_info", "=", "os", ".", "stat", "(", "key_dir", ")", "keydir_gid", "=", "keydir_info", ".", "st_gid", "keydir_uid", "=", "keydir_info", ".", "st_uid", "# Set user and group on keys to the user/group of the key directory", "os", ".", "chown", "(", "priv_filename", ",", "keydir_uid", ",", "keydir_gid", ")", "# Set the private key u+rw g+r", "os", ".", "chmod", "(", "priv_filename", ",", "0o640", ")", "pub_exists", "=", "os", ".", "path", ".", "exists", "(", "pub_filename", ")", "with", "open", "(", "pub_filename", ",", "'w'", ")", "as", "pub_fd", ":", "if", "not", "args", ".", "quiet", ":", "if", "pub_exists", ":", "print", "(", "'overwriting file: {}'", ".", "format", "(", "pub_filename", ")", ")", "else", ":", "print", "(", "'writing file: {}'", ".", "format", "(", "pub_filename", ")", ")", "pub_fd", ".", "write", "(", "public_key", ".", "as_hex", "(", ")", ")", "pub_fd", ".", "write", "(", "'\\n'", ")", "# Set user and group on keys to the user/group of the key directory", "os", ".", "chown", "(", "pub_filename", ",", "keydir_uid", ",", "keydir_gid", ")", "# Set the public key u+rw g+r o+r", "os", ".", "chmod", "(", "pub_filename", ",", "0o644", ")", "except", "IOError", "as", "ioe", ":", "raise", "CliException", "(", "'IOError: {}'", ".", "format", "(", "str", "(", "ioe", ")", ")", ")" ]

[ "Executes", "the", "key", "generation", "operation", "given", "the", "parsed", "arguments", "." ]

[ "def", "abu_flux_chart", "(", "self", ",", "cycle", ",", "ilabel", "=", "True", ",", "imlabel", "=", "True", ",", "imagic", "=", "False", ",", "boxstable", "=", "True", ",", "lbound", "=", "(", "-", "12", ",", "0", ")", ",", "plotaxis", "=", "[", "0", ",", "0", ",", "0", ",", "0", "]", ",", "which_flux", "=", "None", ",", "prange", "=", "None", ",", "profile", "=", "'charged'", ",", "show", "=", "True", ")", ":", "#######################################################################", "#### plot options", "# Set axis limit: If default [0,0,0,0] the complete range in (N,Z) will", "# be plotted, i.e. all isotopes, else specify the limits in", "# plotaxis = [xmin,xmax,ymin,ymax]", "#######################################################################", "# read data file", "#inpfile = cycle", "#ff = fdic.ff(inpfile)", "# with the flux implementation I am not using mass range for now.", "# It may be introduced eventually.", "mass_range", "=", "None", "if", "str", "(", "cycle", ".", "__class__", ")", "==", "\"<type 'list'>\"", ":", "self", ".", "abu_chartMulti", "(", "cycle", ",", "mass_range", ",", "ilabel", ",", "imlabel", ",", "imlabel_fontsize", ",", "imagic", ",", "boxstable", ",", "lbound", ",", "plotaxis", ")", "return", "plotType", "=", "self", ".", "_classTest", "(", ")", "#if mass_range!=None and mass_range[0]>mass_range[1]:", "#print 'Please input a proper mass range'", "#print 'Returning None'", "#return None", "if", "plotType", "==", "'se'", ":", "cycle", "=", "self", ".", "se", ".", "findCycle", "(", "cycle", ")", "nin", "=", "zeros", "(", "len", "(", "self", ".", "se", ".", "A", ")", ")", "zin", "=", "zeros", "(", "len", "(", "self", ".", "se", ".", "Z", ")", ")", "for", "i", "in", "range", "(", "len", "(", "nin", ")", ")", ":", "nin", "[", "i", "]", "=", "self", ".", "se", ".", "A", "[", "i", "]", "zin", "[", "i", "]", "=", "self", ".", "se", ".", "Z", "[", "i", "]", "for", "i", "in", "range", "(", "len", "(", "nin", ")", ")", ":", "nin", "[", "i", "]", "=", "nin", "[", "i", "]", "-", "zin", "[", "i", "]", "yin", "=", "self", ".", "get", "(", "cycle", ",", "'iso_massf'", ")", "isom", "=", "self", ".", "se", ".", "isomeric_states", "masses", "=", "self", ".", "se", ".", "get", "(", "cycle", ",", "'mass'", ")", "if", "mass_range", "!=", "None", ":", "masses", "=", "self", ".", "se", ".", "get", "(", "cycle", ",", "'mass'", ")", "masses", ".", "sort", "(", ")", "if", "mass_range", "!=", "None", ":", "tmpyps", "=", "[", "]", "masses", "=", "self", ".", "se", ".", "get", "(", "cycle", ",", "'mass'", ")", "masses", "=", "self", ".", "se", ".", "get", "(", "cycle", ",", "'mass'", ")", "masses", ".", "sort", "(", ")", "for", "i", "in", "range", "(", "len", "(", "masses", ")", ")", ":", "if", "(", "masses", "[", "i", "]", ">", "mass_range", "[", "0", "]", "and", "masses", "[", "i", "]", "<", "mass_range", "[", "1", "]", ")", "or", "(", "masses", "[", "i", "]", "==", "mass_range", "[", "0", "]", "or", "masses", "[", "i", "]", "==", "mass_range", "[", "1", "]", ")", ":", "tmpyps", ".", "append", "(", "yin", "[", "i", "]", ")", "yin", "=", "tmpyps", "tmp", "=", "zeros", "(", "len", "(", "yin", "[", "0", "]", ")", ")", "for", "i", "in", "range", "(", "len", "(", "yin", ")", ")", ":", "for", "j", "in", "range", "(", "len", "(", "yin", "[", "i", "]", ")", ")", ":", "tmp", "[", "j", "]", "+=", "yin", "[", "i", "]", "[", "j", "]", "tmp", "=", "old_div", "(", "tmp", ",", "len", "(", "yin", ")", ")", "yin", "=", "tmp", "elif", "plotType", "==", "'PPN'", ":", "ain", "=", "self", ".", "get", "(", "'A'", ",", "cycle", ")", "zin", "=", "self", ".", "get", "(", "'Z'", ",", "cycle", ")", "nin", "=", "ain", "-", "zin", "yin", "=", "self", ".", "get", "(", "'ABUNDANCE_MF'", ",", "cycle", ")", "isom", "=", "self", ".", "get", "(", "'ISOM'", ",", "cycle", ")", "if", "mass_range", "!=", "None", ":", "tmpA", "=", "[", "]", "tmpZ", "=", "[", "]", "tmpIsom", "=", "[", "]", "tmpyps", "=", "[", "]", "for", "i", "in", "range", "(", "len", "(", "nin", ")", ")", ":", "if", "(", "ain", "[", "i", "]", ">", "mass_range", "[", "0", "]", "and", "ain", "[", "i", "]", "<", "mass_range", "[", "1", "]", ")", "or", "(", "ain", "[", "i", "]", "==", "mass_range", "[", "0", "]", "or", "ain", "[", "i", "]", "==", "mass_range", "[", "1", "]", ")", ":", "tmpA", ".", "append", "(", "nin", "[", "i", "]", ")", "tmpZ", ".", "append", "(", "zin", "[", "i", "]", ")", "tmpIsom", ".", "append", "(", "isom", "[", "i", "]", ")", "tmpyps", ".", "append", "(", "yin", "[", "i", "]", ")", "zin", "=", "tmpZ", "nin", "=", "tmpA", "yin", "=", "tmpyps", "isom", "=", "tmpIsom", "else", ":", "print", "(", "'This method, abu_chart, is not supported by this class'", ")", "print", "(", "'Returning None'", ")", "return", "None", "# in case we call from ipython -pylab, turn interactive on at end again", "turnoff", "=", "False", "if", "not", "show", ":", "try", ":", "ioff", "(", ")", "turnoff", "=", "True", "except", "NameError", ":", "turnoff", "=", "False", "nnmax", "=", "int", "(", "max", "(", "nin", ")", ")", "+", "1", "nzmax", "=", "int", "(", "max", "(", "zin", ")", ")", "+", "1", "nnmax_plot", "=", "nnmax", "nzmax_plot", "=", "nzmax", "nzycheck", "=", "zeros", "(", "[", "nnmax", ",", "nzmax", ",", "3", "]", ")", "nzycheck_plot", "=", "zeros", "(", "[", "nnmax", ",", "nzmax", ",", "3", "]", ")", "for", "i", "in", "range", "(", "len", "(", "nin", ")", ")", ":", "if", "isom", "[", "i", "]", "==", "1", ":", "ni", "=", "int", "(", "nin", "[", "i", "]", ")", "zi", "=", "int", "(", "zin", "[", "i", "]", ")", "nzycheck", "[", "ni", ",", "zi", ",", "0", "]", "=", "1", "nzycheck", "[", "ni", ",", "zi", ",", "1", "]", "=", "yin", "[", "i", "]", "nzycheck_plot", "[", "ni", ",", "zi", ",", "0", "]", "=", "1", "#######################################################################", "# elemental names: elname(i) is the name of element with Z=i", "elname", "=", "self", ".", "elements_names", "#### create plot", "## define axis and plot style (colormap, size, fontsize etc.)", "if", "plotaxis", "==", "[", "0", ",", "0", ",", "0", ",", "0", "]", ":", "xdim", "=", "10", "ydim", "=", "6", "else", ":", "dx", "=", "plotaxis", "[", "1", "]", "-", "plotaxis", "[", "0", "]", "dy", "=", "plotaxis", "[", "3", "]", "-", "plotaxis", "[", "2", "]", "ydim", "=", "6", "xdim", "=", "ydim", "*", "dx", "/", "dy", "params", "=", "{", "'axes.labelsize'", ":", "15", ",", "'text.fontsize'", ":", "12", ",", "'legend.fontsize'", ":", "15", ",", "'xtick.labelsize'", ":", "15", ",", "'ytick.labelsize'", ":", "15", ",", "'text.usetex'", ":", "True", "}", "#pl.rcParams.update(params) #May cause Error, someting to do with tex", "#fig=pl.figure(figsize=(xdim,ydim),dpi=100)", "fig", "=", "pl", ".", "figure", "(", ")", "if", "profile", "==", "'charged'", ":", "ax1", "=", "fig", ".", "add_subplot", "(", "1", ",", "2", ",", "1", ")", "elif", "profile", "==", "'neutron'", ":", "ax1", "=", "fig", ".", "add_subplot", "(", "2", ",", "1", ",", "1", ")", "#axx = 0.10", "#axy = 0.10", "#axw = 0.85", "#axh = 0.8", "#ax1=pl.axes([axx,axy,axw,axh])", "# Tick marks", "xminorlocator", "=", "MultipleLocator", "(", "1", ")", "xmajorlocator", "=", "MultipleLocator", "(", "5", ")", "ax1", ".", "xaxis", ".", "set_major_locator", "(", "xmajorlocator", ")", "ax1", ".", "xaxis", ".", "set_minor_locator", "(", "xminorlocator", ")", "yminorlocator", "=", "MultipleLocator", "(", "1", ")", "ymajorlocator", "=", "MultipleLocator", "(", "5", ")", "ax1", ".", "yaxis", ".", "set_major_locator", "(", "ymajorlocator", ")", "ax1", ".", "yaxis", ".", "set_minor_locator", "(", "yminorlocator", ")", "# color map choice for abundances", "#cmapa = cm.jet", "cmapa", "=", "cm", ".", "summer", "# color map choice for arrows", "cmapr", "=", "cm", ".", "summer", "# if a value is below the lower limit its set to white", "cmapa", ".", "set_under", "(", "color", "=", "'w'", ")", "cmapr", ".", "set_under", "(", "color", "=", "'w'", ")", "# set value range for abundance colors (log10(Y))", "norma", "=", "colors", ".", "Normalize", "(", "vmin", "=", "lbound", "[", "0", "]", ",", "vmax", "=", "lbound", "[", "1", "]", ")", "# set x- and y-axis scale aspect ratio to 1", "#ax1.set_aspect('equal')", "#print time,temp and density on top", "temp", "=", "' '", "#'%8.3e' %ff['temp']", "time", "=", "' '", "#'%8.3e' %ff['time']", "dens", "=", "' '", "#'%8.3e' %ff['dens']", "#May cause Error, someting to do with tex", "'''\n #box1 = TextArea(\"t : \" + time + \" s~~/~~T$_{9}$ : \" + temp + \"~~/~~$\\\\rho_{b}$ : \" \\\n # + dens + ' g/cm$^{3}$', textprops=dict(color=\"k\"))\n anchored_box = AnchoredOffsetbox(loc=3,\n child=box1, pad=0.,\n frameon=False,\n bbox_to_anchor=(0., 1.02),\n bbox_transform=ax.transAxes,\n borderpad=0.,\n )\n ax.add_artist(anchored_box)\n '''", "## Colour bar plotted", "patches", "=", "[", "]", "color", "=", "[", "]", "for", "i", "in", "range", "(", "nzmax", ")", ":", "for", "j", "in", "range", "(", "nnmax", ")", ":", "if", "nzycheck", "[", "j", ",", "i", ",", "0", "]", "==", "1", ":", "xy", "=", "j", "-", "0.5", ",", "i", "-", "0.5", "rect", "=", "Rectangle", "(", "xy", ",", "1", ",", "1", ",", ")", "# abundance", "yab", "=", "nzycheck", "[", "j", ",", "i", ",", "1", "]", "if", "yab", "==", "0", ":", "yab", "=", "1e-99", "col", "=", "log10", "(", "yab", ")", "patches", ".", "append", "(", "rect", ")", "color", ".", "append", "(", "col", ")", "p", "=", "PatchCollection", "(", "patches", ",", "cmap", "=", "cmapa", ",", "norm", "=", "norma", ")", "p", ".", "set_array", "(", "array", "(", "color", ")", ")", "p", ".", "set_zorder", "(", "1", ")", "ax1", ".", "add_collection", "(", "p", ")", "cb", "=", "pl", ".", "colorbar", "(", "p", ")", "# colorbar label", "if", "profile", "==", "'neutron'", ":", "cb", ".", "set_label", "(", "'log$_{10}$(X)'", ")", "# plot file name", "graphname", "=", "'abundance-flux-chart'", "+", "str", "(", "cycle", ")", "# Add black frames for stable isotopes", "if", "boxstable", ":", "for", "i", "in", "range", "(", "len", "(", "self", ".", "stable_el", ")", ")", ":", "if", "i", "==", "0", ":", "continue", "tmp", "=", "self", ".", "stable_el", "[", "i", "]", "try", ":", "zz", "=", "self", ".", "elements_names", ".", "index", "(", "tmp", "[", "0", "]", ")", "#charge", "except", ":", "continue", "for", "j", "in", "range", "(", "len", "(", "tmp", ")", ")", ":", "if", "j", "==", "0", ":", "continue", "nn", "=", "int", "(", "tmp", "[", "j", "]", ")", "#atomic mass", "nn", "=", "nn", "-", "zz", "xy", "=", "nn", "-", "0.5", ",", "zz", "-", "0.5", "rect", "=", "Rectangle", "(", "xy", ",", "1", ",", "1", ",", "ec", "=", "'k'", ",", "fc", "=", "'None'", ",", "fill", "=", "'False'", ",", "lw", "=", "4.", ")", "rect", ".", "set_zorder", "(", "2", ")", "ax1", ".", "add_patch", "(", "rect", ")", "# decide which array to take for label positions", "iarr", "=", "0", "# plot element labels", "if", "ilabel", ":", "for", "z", "in", "range", "(", "nzmax", ")", ":", "try", ":", "nmin", "=", "min", "(", "argwhere", "(", "nzycheck", "[", ":", ",", "z", ",", "iarr", "]", ")", ")", "[", "0", "]", "-", "1", "nmax", "=", "max", "(", "argwhere", "(", "nzycheck", "[", ":", ",", "z", ",", "iarr", "]", ")", ")", "[", "0", "]", "+", "1", "ax1", ".", "text", "(", "nmin", ",", "z", ",", "elname", "[", "z", "]", ",", "horizontalalignment", "=", "'center'", ",", "verticalalignment", "=", "'center'", ",", "fontsize", "=", "'small'", ",", "clip_on", "=", "True", ")", "ax1", ".", "text", "(", "nmax", ",", "z", ",", "elname", "[", "z", "]", ",", "horizontalalignment", "=", "'center'", ",", "verticalalignment", "=", "'center'", ",", "fontsize", "=", "'small'", ",", "clip_on", "=", "True", ")", "except", "ValueError", ":", "continue", "# plot mass numbers", "if", "imlabel", ":", "for", "z", "in", "range", "(", "nzmax", ")", ":", "for", "n", "in", "range", "(", "nnmax", ")", ":", "a", "=", "z", "+", "n", "if", "nzycheck", "[", "n", ",", "z", ",", "iarr", "]", "==", "1", ":", "ax1", ".", "text", "(", "n", ",", "z", ",", "a", ",", "horizontalalignment", "=", "'center'", ",", "verticalalignment", "=", "'center'", ",", "fontsize", "=", "'x-small'", ",", "clip_on", "=", "True", ")", "# plot lines at magic numbers", "if", "imagic", ":", "ixymagic", "=", "[", "2", ",", "8", ",", "20", ",", "28", ",", "50", ",", "82", ",", "126", "]", "nmagic", "=", "len", "(", "ixymagic", ")", "for", "magic", "in", "ixymagic", ":", "if", "magic", "<=", "nzmax", ":", "try", ":", "xnmin", "=", "min", "(", "argwhere", "(", "nzycheck", "[", ":", ",", "magic", ",", "iarr", "]", ")", ")", "[", "0", "]", "xnmax", "=", "max", "(", "argwhere", "(", "nzycheck", "[", ":", ",", "magic", ",", "iarr", "]", ")", ")", "[", "0", "]", "line", "=", "ax1", ".", "plot", "(", "[", "xnmin", ",", "xnmax", "]", ",", "[", "magic", ",", "magic", "]", ",", "lw", "=", "3.", ",", "color", "=", "'r'", ",", "ls", "=", "'-'", ")", "except", "ValueError", ":", "dummy", "=", "0", "if", "magic", "<=", "nnmax", ":", "try", ":", "yzmin", "=", "min", "(", "argwhere", "(", "nzycheck", "[", "magic", ",", ":", ",", "iarr", "]", ")", ")", "[", "0", "]", "yzmax", "=", "max", "(", "argwhere", "(", "nzycheck", "[", "magic", ",", ":", ",", "iarr", "]", ")", ")", "[", "0", "]", "line", "=", "ax1", ".", "plot", "(", "[", "magic", ",", "magic", "]", ",", "[", "yzmin", ",", "yzmax", "]", ",", "lw", "=", "3.", ",", "color", "=", "'r'", ",", "ls", "=", "'-'", ")", "except", "ValueError", ":", "dummy", "=", "0", "# set axis limits", "if", "plotaxis", "==", "[", "0", ",", "0", ",", "0", ",", "0", "]", ":", "xmax", "=", "max", "(", "nin", ")", "ymax", "=", "max", "(", "zin", ")", "ax1", ".", "axis", "(", "[", "-", "0.5", ",", "xmax", "+", "0.5", ",", "-", "0.5", ",", "ymax", "+", "0.5", "]", ")", "else", ":", "ax1", ".", "axis", "(", "plotaxis", ")", "# set x- and y-axis label", "ax1", ".", "set_ylabel", "(", "'Proton number'", ")", "if", "profile", "==", "'charged'", ":", "ax1", ".", "set_xlabel", "(", "'Neutron number'", ")", "#pl.title('Isotopic Chart for cycle '+str(int(cycle)))", "#", "# here below I read data from the flux_*****.DAT file.", "#", "file_name", "=", "'flux_'", "+", "str", "(", "cycle", ")", ".", "zfill", "(", "5", ")", "+", "'.DAT'", "print", "(", "file_name", ")", "f", "=", "open", "(", "file_name", ")", "lines", "=", "f", ".", "readline", "(", ")", "lines", "=", "f", ".", "readlines", "(", ")", "f", ".", "close", "(", ")", "print_max_flux_in_plot", "=", "False", "# color map choice for fluxes", "#cmapa = cm.jet", "cmapa", "=", "cm", ".", "autumn", "# color map choice for arrows", "cmapr", "=", "cm", ".", "autumn", "# starting point of arrow", "coord_x_1", "=", "[", "]", "coord_y_1", "=", "[", "]", "# ending point of arrow (option 1)", "coord_x_2", "=", "[", "]", "coord_y_2", "=", "[", "]", "# ending point of arrow (option 2)", "coord_x_3", "=", "[", "]", "coord_y_3", "=", "[", "]", "# fluxes", "flux_read", "=", "[", "]", "flux_log10", "=", "[", "]", "if", "which_flux", "==", "None", "or", "which_flux", "==", "0", ":", "print", "(", "'chart for nucleosynthesis fluxes [dYi/dt]'", ")", "line_to_read", "=", "9", "elif", "which_flux", "==", "1", ":", "print", "(", "'chart for energy fluxes'", ")", "line_to_read", "=", "10", "elif", "which_flux", ">", "1", ":", "print", "(", "\"you have only option 0 or 1, not larger than 1\"", ")", "single_line", "=", "[", "]", "for", "i", "in", "range", "(", "len", "(", "lines", ")", ")", ":", "single_line", ".", "append", "(", "lines", "[", "i", "]", ".", "split", "(", ")", ")", "coord_y_1", ".", "append", "(", "int", "(", "single_line", "[", "i", "]", "[", "1", "]", ")", ")", "coord_x_1", ".", "append", "(", "int", "(", "single_line", "[", "i", "]", "[", "2", "]", ")", "-", "coord_y_1", "[", "i", "]", ")", "coord_y_2", ".", "append", "(", "int", "(", "single_line", "[", "i", "]", "[", "5", "]", ")", ")", "coord_x_2", ".", "append", "(", "int", "(", "single_line", "[", "i", "]", "[", "6", "]", ")", "-", "coord_y_2", "[", "i", "]", ")", "coord_y_3", ".", "append", "(", "int", "(", "single_line", "[", "i", "]", "[", "7", "]", ")", ")", "coord_x_3", ".", "append", "(", "int", "(", "single_line", "[", "i", "]", "[", "8", "]", ")", "-", "coord_y_3", "[", "i", "]", ")", "try", ":", "flux_read", ".", "append", "(", "float", "(", "single_line", "[", "i", "]", "[", "line_to_read", "]", ")", ")", "except", "ValueError", ":", "# this is done to avoid format issues like 3.13725-181...", "flux_read", ".", "append", "(", "1.0E-99", ")", "flux_log10", ".", "append", "(", "log10", "(", "flux_read", "[", "i", "]", "+", "1.0e-99", ")", ")", "print", "(", "file_name", ",", "' read!'", ")", "# I need to select smaller sample, with only fluxes inside plotaxis.", "if", "plotaxis", "!=", "[", "0", ",", "0", ",", "0", ",", "0", "]", ":", "coord_y_1_small", "=", "[", "]", "coord_x_1_small", "=", "[", "]", "coord_y_2_small", "=", "[", "]", "coord_x_2_small", "=", "[", "]", "coord_y_3_small", "=", "[", "]", "coord_x_3_small", "=", "[", "]", "flux_log10_small", "=", "[", "]", "for", "i", "in", "range", "(", "len", "(", "flux_log10", ")", ")", ":", "I_am_in", "=", "0", "if", "coord_y_1", "[", "i", "]", ">", "plotaxis", "[", "2", "]", "and", "coord_y_1", "[", "i", "]", "<", "plotaxis", "[", "3", "]", "and", "coord_x_1", "[", "i", "]", ">", "plotaxis", "[", "0", "]", "and", "coord_x_1", "[", "i", "]", "<", "plotaxis", "[", "1", "]", ":", "I_am_in", "=", "1", "coord_y_1_small", ".", "append", "(", "int", "(", "coord_y_1", "[", "i", "]", ")", ")", "coord_x_1_small", ".", "append", "(", "int", "(", "coord_x_1", "[", "i", "]", ")", ")", "coord_y_2_small", ".", "append", "(", "int", "(", "coord_y_2", "[", "i", "]", ")", ")", "coord_x_2_small", ".", "append", "(", "int", "(", "coord_x_2", "[", "i", "]", ")", ")", "coord_y_3_small", ".", "append", "(", "int", "(", "coord_y_3", "[", "i", "]", ")", ")", "coord_x_3_small", ".", "append", "(", "int", "(", "coord_x_3", "[", "i", "]", ")", ")", "flux_log10_small", ".", "append", "(", "flux_log10", "[", "i", "]", ")", "if", "coord_y_3", "[", "i", "]", ">", "plotaxis", "[", "2", "]", "and", "coord_y_3", "[", "i", "]", "<", "plotaxis", "[", "3", "]", "and", "coord_x_3", "[", "i", "]", ">", "plotaxis", "[", "0", "]", "and", "coord_x_3", "[", "i", "]", "<", "plotaxis", "[", "1", "]", "and", "I_am_in", "==", "0", ":", "I_am_in", "=", "1", "coord_y_1_small", ".", "append", "(", "int", "(", "coord_y_1", "[", "i", "]", ")", ")", "coord_x_1_small", ".", "append", "(", "int", "(", "coord_x_1", "[", "i", "]", ")", ")", "coord_y_2_small", ".", "append", "(", "int", "(", "coord_y_2", "[", "i", "]", ")", ")", "coord_x_2_small", ".", "append", "(", "int", "(", "coord_x_2", "[", "i", "]", ")", ")", "coord_y_3_small", ".", "append", "(", "int", "(", "coord_y_3", "[", "i", "]", ")", ")", "coord_x_3_small", ".", "append", "(", "int", "(", "coord_x_3", "[", "i", "]", ")", ")", "flux_log10_small", ".", "append", "(", "flux_log10", "[", "i", "]", ")", "# elemental labels off/on [0/1]", "ilabel", "=", "1", "# label for isotopic masses off/on [0/1]", "imlabel", "=", "1", "# turn lines for magic numbers off/on [0/1]", "imagic", "=", "0", "# flow is plotted over \"prange\" dex. If flow < maxflow-prange it is not plotted", "if", "prange", "==", "None", ":", "print", "(", "'plot range given by default'", ")", "prange", "=", "8.", "#############################################", "#print flux_log10_small", "# we should scale prange on plot_axis range, not on max_flux!", "max_flux", "=", "max", "(", "flux_log10", ")", "ind_max_flux", "=", "flux_log10", ".", "index", "(", "max_flux", ")", "if", "plotaxis", "!=", "[", "0", ",", "0", ",", "0", ",", "0", "]", ":", "max_flux_small", "=", "max", "(", "flux_log10_small", ")", "if", "plotaxis", "==", "[", "0", ",", "0", ",", "0", ",", "0", "]", ":", "nzmax", "=", "int", "(", "max", "(", "max", "(", "coord_y_1", ")", ",", "max", "(", "coord_y_2", ")", ",", "max", "(", "coord_y_3", ")", ")", ")", "+", "1", "nnmax", "=", "int", "(", "max", "(", "max", "(", "coord_x_1", ")", ",", "max", "(", "coord_x_2", ")", ",", "max", "(", "coord_x_3", ")", ")", ")", "+", "1", "coord_x_1_small", "=", "coord_x_1", "coord_x_2_small", "=", "coord_x_2", "coord_x_3_small", "=", "coord_x_3", "coord_y_1_small", "=", "coord_y_1", "coord_y_2_small", "=", "coord_y_2", "coord_y_3_small", "=", "coord_y_3", "flux_log10_small", "=", "flux_log10", "max_flux_small", "=", "max_flux", "else", ":", "nzmax", "=", "int", "(", "max", "(", "max", "(", "coord_y_1_small", ")", ",", "max", "(", "coord_y_2_small", ")", ",", "max", "(", "coord_y_3_small", ")", ")", ")", "+", "1", "nnmax", "=", "int", "(", "max", "(", "max", "(", "coord_x_1_small", ")", ",", "max", "(", "coord_x_2_small", ")", ",", "max", "(", "coord_x_3_small", ")", ")", ")", "+", "1", "for", "i", "in", "range", "(", "nzmax", ")", ":", "for", "j", "in", "range", "(", "nnmax", ")", ":", "if", "nzycheck", "[", "j", ",", "i", ",", "0", "]", "==", "1", ":", "xy", "=", "j", "-", "0.5", ",", "i", "-", "0.5", "rect", "=", "Rectangle", "(", "xy", ",", "1", ",", "1", ",", ")", "patches", ".", "append", "(", "rect", ")", "nzycheck", "=", "zeros", "(", "[", "nnmax_plot", ",", "nzmax", ",", "3", "]", ")", "coord_x_out", "=", "zeros", "(", "len", "(", "coord_x_2_small", ")", ",", "dtype", "=", "'int'", ")", "coord_y_out", "=", "zeros", "(", "len", "(", "coord_y_2_small", ")", ",", "dtype", "=", "'int'", ")", "for", "i", "in", "range", "(", "len", "(", "flux_log10_small", ")", ")", ":", "nzycheck", "[", "coord_x_1_small", "[", "i", "]", ",", "coord_y_1_small", "[", "i", "]", ",", "0", "]", "=", "1", "nzycheck", "[", "coord_x_1_small", "[", "i", "]", ",", "coord_y_1_small", "[", "i", "]", ",", "1", "]", "=", "flux_log10_small", "[", "i", "]", "if", "coord_x_2_small", "[", "i", "]", ">=", "coord_x_3_small", "[", "i", "]", ":", "coord_x_out", "[", "i", "]", "=", "coord_x_2_small", "[", "i", "]", "coord_y_out", "[", "i", "]", "=", "coord_y_2_small", "[", "i", "]", "nzycheck", "[", "coord_x_out", "[", "i", "]", ",", "coord_y_out", "[", "i", "]", ",", "0", "]", "=", "1", "nzycheck", "[", "coord_x_out", "[", "i", "]", ",", "coord_y_out", "[", "i", "]", ",", "1", "]", "=", "flux_log10_small", "[", "i", "]", "elif", "coord_x_2_small", "[", "i", "]", "<", "coord_x_3_small", "[", "i", "]", ":", "coord_x_out", "[", "i", "]", "=", "coord_x_3_small", "[", "i", "]", "coord_y_out", "[", "i", "]", "=", "coord_y_3_small", "[", "i", "]", "nzycheck", "[", "coord_x_out", "[", "i", "]", ",", "coord_y_out", "[", "i", "]", ",", "0", "]", "=", "1", "nzycheck", "[", "coord_x_out", "[", "i", "]", ",", "coord_y_out", "[", "i", "]", ",", "1", "]", "=", "flux_log10_small", "[", "i", "]", "if", "flux_log10_small", "[", "i", "]", ">", "max_flux_small", "-", "prange", ":", "nzycheck", "[", "coord_x_1_small", "[", "i", "]", ",", "coord_y_1_small", "[", "i", "]", ",", "2", "]", "=", "1", "nzycheck", "[", "coord_x_out", "[", "i", "]", ",", "coord_y_out", "[", "i", "]", ",", "2", "]", "=", "1", "#### create plot", "if", "profile", "==", "'charged'", ":", "ax2", "=", "fig", ".", "add_subplot", "(", "1", ",", "2", ",", "2", ")", "elif", "profile", "==", "'neutron'", ":", "ax2", "=", "fig", ".", "add_subplot", "(", "2", ",", "1", ",", "2", ")", "# Tick marks", "xminorlocator", "=", "MultipleLocator", "(", "1", ")", "xmajorlocator", "=", "MultipleLocator", "(", "5", ")", "ax2", ".", "xaxis", ".", "set_major_locator", "(", "xmajorlocator", ")", "ax2", ".", "xaxis", ".", "set_minor_locator", "(", "xminorlocator", ")", "yminorlocator", "=", "MultipleLocator", "(", "1", ")", "ymajorlocator", "=", "MultipleLocator", "(", "5", ")", "ax2", ".", "yaxis", ".", "set_major_locator", "(", "ymajorlocator", ")", "ax2", ".", "yaxis", ".", "set_minor_locator", "(", "yminorlocator", ")", "## define axis and plot style (colormap, size, fontsize etc.)", "if", "plotaxis", "==", "[", "0", ",", "0", ",", "0", ",", "0", "]", ":", "xdim", "=", "10", "ydim", "=", "6", "else", ":", "dx", "=", "plotaxis", "[", "1", "]", "-", "plotaxis", "[", "0", "]", "dy", "=", "plotaxis", "[", "3", "]", "-", "plotaxis", "[", "2", "]", "ydim", "=", "6", "xdim", "=", "ydim", "*", "dx", "/", "dy", "format", "=", "'pdf'", "# set x- and y-axis scale aspect ratio to 1", "#ax2.set_aspect('equal')", "# Add black frames for stable isotopes", "# Add black frames for stable isotopes", "if", "boxstable", ":", "for", "i", "in", "range", "(", "len", "(", "self", ".", "stable_el", ")", ")", ":", "if", "i", "==", "0", ":", "continue", "tmp", "=", "self", ".", "stable_el", "[", "i", "]", "try", ":", "zz", "=", "self", ".", "elements_names", ".", "index", "(", "tmp", "[", "0", "]", ")", "#charge", "except", ":", "continue", "for", "j", "in", "range", "(", "len", "(", "tmp", ")", ")", ":", "if", "j", "==", "0", ":", "continue", "nn", "=", "int", "(", "tmp", "[", "j", "]", ")", "#atomic mass", "nn", "=", "nn", "-", "zz", "xy", "=", "nn", "-", "0.5", ",", "zz", "-", "0.5", "rect", "=", "Rectangle", "(", "xy", ",", "1", ",", "1", ",", "ec", "=", "'k'", ",", "fc", "=", "'None'", ",", "fill", "=", "'False'", ",", "lw", "=", "4.", ")", "rect", ".", "set_zorder", "(", "2", ")", "ax2", ".", "add_patch", "(", "rect", ")", "apatches", "=", "[", "]", "acolor", "=", "[", "]", "m", "=", "old_div", "(", "0.8", ",", "prange", ")", "vmax", "=", "ceil", "(", "max", "(", "flux_log10_small", ")", ")", "vmin", "=", "max", "(", "flux_log10_small", ")", "-", "prange", "b", "=", "-", "vmin", "*", "m", "+", "0.1", "normr", "=", "colors", ".", "Normalize", "(", "vmin", "=", "vmin", ",", "vmax", "=", "vmax", ")", "ymax", "=", "0.", "xmax", "=", "0.", "for", "i", "in", "range", "(", "len", "(", "flux_log10_small", ")", ")", ":", "x", "=", "coord_x_1_small", "[", "i", "]", "y", "=", "coord_y_1_small", "[", "i", "]", "dx", "=", "coord_x_out", "[", "i", "]", "-", "coord_x_1_small", "[", "i", "]", "dy", "=", "coord_y_out", "[", "i", "]", "-", "coord_y_1_small", "[", "i", "]", "if", "flux_log10_small", "[", "i", "]", ">=", "vmin", ":", "arrowwidth", "=", "flux_log10_small", "[", "i", "]", "*", "m", "+", "b", "arrow", "=", "Arrow", "(", "x", ",", "y", ",", "dx", ",", "dy", ",", "width", "=", "arrowwidth", ")", "if", "xmax", "<", "x", ":", "xmax", "=", "x", "if", "ymax", "<", "y", ":", "ymax", "=", "y", "acol", "=", "flux_log10_small", "[", "i", "]", "apatches", ".", "append", "(", "arrow", ")", "acolor", ".", "append", "(", "acol", ")", "xy", "=", "x", "-", "0.5", ",", "y", "-", "0.5", "rect", "=", "Rectangle", "(", "xy", ",", "1", ",", "1", ",", "ec", "=", "'k'", ",", "fc", "=", "'None'", ",", "fill", "=", "'False'", ",", "lw", "=", "1.", ")", "patches", ".", "append", "(", "rect", ")", "xy", "=", "x", "+", "dx", "-", "0.5", ",", "y", "+", "dy", "-", "0.5", "rect", "=", "Rectangle", "(", "xy", ",", "1", ",", "1", ",", "ec", "=", "'k'", ",", "fc", "=", "'None'", ",", "fill", "=", "'False'", ",", "lw", "=", "1.", ")", "patches", ".", "append", "(", "rect", ")", "p", "=", "PatchCollection", "(", "patches", ",", "norm", "=", "0", ",", "facecolor", "=", "'w'", ")", "p", ".", "set_zorder", "(", "1", ")", "ax2", ".", "add_collection", "(", "p", ")", "a", "=", "PatchCollection", "(", "apatches", ",", "cmap", "=", "cmapr", ",", "norm", "=", "normr", ")", "a", ".", "set_array", "(", "array", "(", "acolor", ")", ")", "a", ".", "set_zorder", "(", "3", ")", "ax2", ".", "add_collection", "(", "a", ")", "cb", "=", "pl", ".", "colorbar", "(", "a", ")", "# colorbar label", "cb", ".", "set_label", "(", "'log$_{10}$($x$)'", ")", "if", "profile", "==", "'neutron'", ":", "cb", ".", "set_label", "(", "'log$_{10}$(f)'", ")", "# decide which array to take for label positions", "iarr", "=", "2", "# plot element labels", "for", "z", "in", "range", "(", "nzmax", ")", ":", "try", ":", "nmin", "=", "min", "(", "argwhere", "(", "nzycheck_plot", "[", ":", ",", "z", ",", "iarr", "-", "2", "]", ")", ")", "[", "0", "]", "-", "1", "nmax", "=", "max", "(", "argwhere", "(", "nzycheck_plot", "[", ":", ",", "z", ",", "iarr", "-", "2", "]", ")", ")", "[", "0", "]", "+", "1", "ax2", ".", "text", "(", "nmin", ",", "z", ",", "elname", "[", "z", "]", ",", "horizontalalignment", "=", "'center'", ",", "verticalalignment", "=", "'center'", ",", "fontsize", "=", "'small'", ",", "clip_on", "=", "True", ")", "ax2", ".", "text", "(", "nmax", ",", "z", ",", "elname", "[", "z", "]", ",", "horizontalalignment", "=", "'center'", ",", "verticalalignment", "=", "'center'", ",", "fontsize", "=", "'small'", ",", "clip_on", "=", "True", ")", "except", "ValueError", ":", "continue", "# plot mass numbers", "if", "imlabel", ":", "for", "z", "in", "range", "(", "nzmax", ")", ":", "for", "n", "in", "range", "(", "nnmax_plot", ")", ":", "a", "=", "z", "+", "n", "if", "nzycheck_plot", "[", "n", ",", "z", ",", "iarr", "-", "2", "]", "==", "1", ":", "ax2", ".", "text", "(", "n", ",", "z", ",", "a", ",", "horizontalalignment", "=", "'center'", ",", "verticalalignment", "=", "'center'", ",", "fontsize", "=", "'x-small'", ",", "clip_on", "=", "True", ")", "# plot lines at magic numbers", "if", "imagic", "==", "1", ":", "ixymagic", "=", "[", "2", ",", "8", ",", "20", ",", "28", ",", "50", ",", "82", ",", "126", "]", "nmagic", "=", "len", "(", "ixymagic", ")", "for", "magic", "in", "ixymagic", ":", "if", "magic", "<=", "nzmax", ":", "try", ":", "xnmin", "=", "min", "(", "argwhere", "(", "nzycheck", "[", ":", ",", "magic", ",", "iarr", "-", "2", "]", ")", ")", "[", "0", "]", "xnmax", "=", "max", "(", "argwhere", "(", "nzycheck", "[", ":", ",", "magic", ",", "iarr", "-", "2", "]", ")", ")", "[", "0", "]", "line", "=", "ax2", ".", "plot", "(", "[", "xnmin", ",", "xnmax", "]", ",", "[", "magic", ",", "magic", "]", ",", "lw", "=", "3.", ",", "color", "=", "'r'", ",", "ls", "=", "'-'", ")", "except", "ValueError", ":", "dummy", "=", "0", "if", "magic", "<=", "nnmax", ":", "try", ":", "yzmin", "=", "min", "(", "argwhere", "(", "nzycheck", "[", "magic", ",", ":", ",", "iarr", "-", "2", "]", ")", ")", "[", "0", "]", "yzmax", "=", "max", "(", "argwhere", "(", "nzycheck", "[", "magic", ",", ":", ",", "iarr", "-", "2", "]", ")", ")", "[", "0", "]", "line", "=", "ax2", ".", "plot", "(", "[", "magic", ",", "magic", "]", ",", "[", "yzmin", ",", "yzmax", "]", ",", "lw", "=", "3.", ",", "color", "=", "'r'", ",", "ls", "=", "'-'", ")", "except", "ValueError", ":", "dummy", "=", "0", "# set axis limits", "if", "plotaxis", "==", "[", "0", ",", "0", ",", "0", ",", "0", "]", ":", "ax2", ".", "axis", "(", "[", "-", "0.5", ",", "xmax", "+", "0.5", ",", "-", "0.5", ",", "ymax", "+", "0.5", "]", ")", "else", ":", "ax2", ".", "axis", "(", "plotaxis", ")", "# set x- and y-axis label", "ax2", ".", "set_xlabel", "(", "'Neutron number'", ")", "if", "profile", "==", "'neutron'", ":", "ax2", ".", "set_ylabel", "(", "'Proton number'", ")", "if", "which_flux", "==", "None", "or", "which_flux", "==", "0", ":", "max_flux_label", "=", "\"max flux = \"", "+", "str", "(", "'{0:.4f}'", ".", "format", "(", "max_flux", ")", ")", "elif", "which_flux", "==", "1", ":", "max_flux_label", "=", "\"max energy flux = \"", "+", "str", "(", "'{0:.4f}'", ".", "format", "(", "max_flux", ")", ")", "if", "print_max_flux_in_plot", ":", "ax2", ".", "text", "(", "plotaxis", "[", "1", "]", "-", "1.8", ",", "plotaxis", "[", "2", "]", "+", "0.1", ",", "max_flux_label", ",", "fontsize", "=", "10.", ")", "#fig.savefig(graphname)", "print", "(", "graphname", ",", "'is done'", ")", "if", "show", ":", "pl", ".", "show", "(", ")", "if", "turnoff", ":", "ion", "(", ")", "return" ]

[ "Plots", "an", "abundance", "and", "flux", "chart" ]

[ "def", "get_conn", "(", "self", ")", ":", "conn", "=", "self", ".", "get_connection", "(", "self", ".", "druid_broker_conn_id", ")", "druid_broker_conn", "=", "connect", "(", "host", "=", "conn", ".", "host", ",", "port", "=", "conn", ".", "port", ",", "path", "=", "conn", ".", "extra_dejson", ".", "get", "(", "'endpoint'", ",", "'/druid/v2/sql'", ")", ",", "scheme", "=", "conn", ".", "extra_dejson", ".", "get", "(", "'schema'", ",", "'http'", ")", ")", "self", ".", "log", ".", "info", "(", "'Get the connection to druid broker on %s'", ",", "conn", ".", "host", ")", "return", "druid_broker_conn" ]

[ "Establish", "a", "connection", "to", "druid", "broker", "." ]

[ "def", "add", "(", "self", ",", "urls", ")", ":", "if", "isinstance", "(", "urls", ",", "(", "list", ",", "tuple", ")", ")", ":", "self", ".", "urls", ".", "extend", "(", "urls", ")", "elif", "isinstance", "(", "urls", ",", "basestring", ")", ":", "self", ".", "urls", ".", "append", "(", "urls", ")", "elif", "isinstance", "(", "urls", ",", "QuerySet", ")", ":", "for", "obj", "in", "urls", ":", "self", ".", "urls", ".", "append", "(", "obj", ".", "get_absolute_url", "(", ")", ")", "elif", "hasattr", "(", "urls", ",", "'get_absolute_url'", ")", ":", "self", ".", "urls", ".", "append", "(", "urls", ".", "get_absolute_url", "(", ")", ")", "else", ":", "raise", "TypeError", "(", "\"Don't know how to handle %r\"", "%", "urls", ")" ]

[ "Add", "the", "provided", "urls", "to", "this", "purge", "request" ]

[ "def", "closenessScores", "(", "self", ",", "expValues", ",", "actValues", ",", "fractional", "=", "True", ")", ":", "# Compute the percent error in log space", "if", "expValues", "[", "0", "]", ">", "0", ":", "expValue", "=", "math", ".", "log10", "(", "expValues", "[", "0", "]", ")", "else", ":", "expValue", "=", "self", ".", "minScaledValue", "if", "actValues", "[", "0", "]", ">", "0", ":", "actValue", "=", "math", ".", "log10", "(", "actValues", "[", "0", "]", ")", "else", ":", "actValue", "=", "self", ".", "minScaledValue", "if", "fractional", ":", "err", "=", "abs", "(", "expValue", "-", "actValue", ")", "pctErr", "=", "err", "/", "(", "self", ".", "maxScaledValue", "-", "self", ".", "minScaledValue", ")", "pctErr", "=", "min", "(", "1.0", ",", "pctErr", ")", "closeness", "=", "1.0", "-", "pctErr", "else", ":", "err", "=", "abs", "(", "expValue", "-", "actValue", ")", "closeness", "=", "err", "#print \"log::\", \"expValue:\", expValues[0], \"actValue:\", actValues[0], \\", "# \"closeness\", closeness", "#import pdb; pdb.set_trace()", "return", "numpy", ".", "array", "(", "[", "closeness", "]", ")" ]

[ "See", "the", "function", "description", "in", "base", ".", "py" ]

[ "def", "inject_documentation", "(", "*", "*", "options", ")", ":", "import", "cog", "loader", "=", "ConfigLoader", "(", "*", "*", "options", ")", "cog", ".", "out", "(", "\"\\n\"", "+", "loader", ".", "documentation", "+", "\"\\n\\n\"", ")" ]

[ "Generate", "configuration", "documentation", "in", "reStructuredText_", "syntax", "." ]

[ "def", "update", "(", "self", ",", "n", "=", "1", ")", ":", "with", "self", ".", "_lock", ":", "self", ".", "_pbar", ".", "update", "(", "n", ")", "self", ".", "refresh", "(", ")" ]

[ "Increment", "current", "value", "." ]

[ "def", "get_offers_per_page", "(", "self", ",", "per_page", "=", "1000", ",", "page", "=", "1", ",", "params", "=", "None", ")", ":", "return", "self", ".", "_get_resource_per_page", "(", "resource", "=", "OFFERS", ",", "per_page", "=", "per_page", ",", "page", "=", "page", ",", "params", "=", "params", ")" ]

[ "Get", "offers", "per", "page" ]

[ "def", "fftshift", "(", "arr_obj", ",", "axes", "=", "None", ",", "res_g", "=", "None", ",", "return_buffer", "=", "False", ")", ":", "if", "axes", "is", "None", ":", "axes", "=", "list", "(", "range", "(", "arr_obj", ".", "ndim", ")", ")", "if", "isinstance", "(", "arr_obj", ",", "OCLArray", ")", ":", "if", "not", "arr_obj", ".", "dtype", ".", "type", "in", "DTYPE_KERNEL_NAMES", ":", "raise", "NotImplementedError", "(", "\"only works for float32 or complex64\"", ")", "elif", "isinstance", "(", "arr_obj", ",", "np", ".", "ndarray", ")", ":", "if", "np", ".", "iscomplexobj", "(", "arr_obj", ")", ":", "arr_obj", "=", "OCLArray", ".", "from_array", "(", "arr_obj", ".", "astype", "(", "np", ".", "complex64", ",", "copy", "=", "False", ")", ")", "else", ":", "arr_obj", "=", "OCLArray", ".", "from_array", "(", "arr_obj", ".", "astype", "(", "np", ".", "float32", ",", "copy", "=", "False", ")", ")", "else", ":", "raise", "ValueError", "(", "\"unknown type (%s)\"", "%", "(", "type", "(", "arr_obj", ")", ")", ")", "if", "not", "np", ".", "all", "(", "[", "arr_obj", ".", "shape", "[", "a", "]", "%", "2", "==", "0", "for", "a", "in", "axes", "]", ")", ":", "raise", "NotImplementedError", "(", "\"only works on axes of even dimensions\"", ")", "if", "res_g", "is", "None", ":", "res_g", "=", "OCLArray", ".", "empty_like", "(", "arr_obj", ")", "# iterate over all axes", "# FIXME: this is still rather inefficient", "in_g", "=", "arr_obj", "for", "ax", "in", "axes", ":", "_fftshift_single", "(", "in_g", ",", "res_g", ",", "ax", ")", "in_g", "=", "res_g", "if", "return_buffer", ":", "return", "res_g", "else", ":", "return", "res_g", ".", "get", "(", ")" ]

[ "gpu", "version", "of", "fftshift", "for", "numpy", "arrays", "or", "OCLArrays" ]

[ "def", "tf_from_file", "(", "cls", ",", "path", ",", "delimiter", "=", "\" \"", ")", ":", "data", "=", "np", ".", "loadtxt", "(", "path", ",", "delimiter", "=", "delimiter", ")", "freq", "=", "data", "[", ":", ",", "0", "]", "h", "=", "data", "[", ":", ",", "1", "]", "+", "1.0j", "*", "data", "[", ":", ",", "2", "]", "return", "np", ".", "array", "(", "[", "freq", ",", "h", "]", ")", ".", "transpose", "(", ")" ]

[ "Convert", "the", "contents", "of", "a", "file", "with", "the", "columns", "[", "freq", "real", "(", "h", ")", "imag", "(", "h", ")", "]", "to", "a", "numpy", ".", "array", "with", "columns", "[", "freq", "real", "(", "h", ")", "+", "j", "*", "imag", "(", "h", ")", "]", "." ]

[ "def", "set_version", "(", "self", ",", "version", ",", "force", "=", "True", ")", ":", "if", "version", "in", "self", ".", "versions", ":", "self", ".", "_version", "=", "version", "if", "'working'", "in", "self", ".", "repo", ".", "branch", "(", ")", ".", "stdout", ":", "if", "force", ":", "logger", ".", "info", "(", "'Found working branch. Removing...'", ")", "cmd", "=", "self", ".", "repo", ".", "checkout", "(", "'master'", ")", "cmd", "=", "self", ".", "repo", ".", "branch", "(", "'working'", ",", "d", "=", "True", ")", "else", ":", "logger", ".", "info", "(", "'Found working branch from previous session. Use force=True to remove it and start anew.'", ")", "return", "stdout", "=", "self", ".", "repo", ".", "checkout", "(", "version", ",", "b", "=", "'working'", ")", ".", "stdout", "# active version set in 'working' branch", "logger", ".", "info", "(", "'Version {0} set'", ".", "format", "(", "version", ")", ")", "else", ":", "raise", "AttributeError", "(", "'Version {0} not found'", ".", "format", "(", "version", ")", ")" ]

[ "Sets", "the", "version", "name", "for", "the", "current", "state", "of", "repo" ]

[ "def", "trace_set_buffer_capacity", "(", "self", ",", "size", ")", ":", "cmd", "=", "enums", ".", "JLinkTraceCommand", ".", "SET_CAPACITY", "data", "=", "ctypes", ".", "c_uint32", "(", "size", ")", "res", "=", "self", ".", "_dll", ".", "JLINKARM_TRACE_Control", "(", "cmd", ",", "ctypes", ".", "byref", "(", "data", ")", ")", "if", "(", "res", "==", "1", ")", ":", "raise", "errors", ".", "JLinkException", "(", "'Failed to set trace buffer size.'", ")", "return", "None" ]

[ "Sets", "the", "capacity", "for", "the", "trace", "buffer", "." ]

[ "def", "get_ogr_driver", "(", "filepath", ")", ":", "filename", ",", "file_extension", "=", "os", ".", "path", ".", "splitext", "(", "filepath", ")", "EXTENSION", "=", "file_extension", "[", "1", ":", "]", "ogr_driver_count", "=", "ogr", ".", "GetDriverCount", "(", ")", "for", "idx", "in", "range", "(", "ogr_driver_count", ")", ":", "driver", "=", "ogr", ".", "GetDriver", "(", "idx", ")", "driver_extension", "=", "driver", ".", "GetMetadataItem", "(", "str", "(", "'DMD_EXTENSION'", ")", ")", "or", "''", "driver_extensions", "=", "driver", ".", "GetMetadataItem", "(", "str", "(", "'DMD_EXTENSIONS'", ")", ")", "or", "''", "if", "EXTENSION", "==", "driver_extension", "or", "EXTENSION", "in", "driver_extensions", ":", "return", "driver", "else", ":", "msg", "=", "'No driver found for the following file extension: {}'", ".", "format", "(", "EXTENSION", ")", "raise", "ValueError", "(", "msg", ")" ]

[ "Get", "the", "OGR", "driver", "from", "the", "provided", "file", "extension", "." ]

[ "def", "chebi", "(", "name", "=", "None", ",", "identifier", "=", "None", ")", "->", "Abundance", ":", "return", "Abundance", "(", "namespace", "=", "'CHEBI'", ",", "name", "=", "name", ",", "identifier", "=", "identifier", ")" ]

[ "Build", "a", "ChEBI", "abundance", "node", "." ]

[ "def", "velocity_from_bundle", "(", "self", ",", "bundle", ")", ":", "coefficients", ",", "days_per_set", ",", "T", ",", "twot1", "=", "bundle", "coefficient_count", "=", "coefficients", ".", "shape", "[", "2", "]", "# Chebyshev derivative:", "dT", "=", "np", ".", "empty_like", "(", "T", ")", "dT", "[", "0", "]", "=", "0.0", "dT", "[", "1", "]", "=", "1.0", "dT", "[", "2", "]", "=", "twot1", "+", "twot1", "for", "i", "in", "range", "(", "3", ",", "coefficient_count", ")", ":", "dT", "[", "i", "]", "=", "twot1", "*", "dT", "[", "i", "-", "1", "]", "-", "dT", "[", "i", "-", "2", "]", "+", "T", "[", "i", "-", "1", "]", "+", "T", "[", "i", "-", "1", "]", "dT", "*=", "2.0", "dT", "/=", "days_per_set", "return", "(", "dT", ".", "T", "*", "coefficients", ")", ".", "sum", "(", "axis", "=", "2", ")" ]

[ "[", "DEPRECATED", "]", "Return", "velocity", "given", "the", "coefficient_bundle", "()", "return", "value", "." ]

[ "def", "replace", "(", "doc", ",", "pointer", ",", "value", ")", ":", "return", "Target", "(", "doc", ")", ".", "replace", "(", "pointer", ",", "value", ")", ".", "document" ]

[ "Replace", "element", "from", "sequence", "member", "from", "mapping", "." ]

[ "def", "perform_command", "(", "self", ")", ":", "if", "len", "(", "self", ".", "actual_arguments", ")", "<", "2", ":", "return", "self", ".", "print_help", "(", ")", "input_file_path", "=", "self", ".", "actual_arguments", "[", "0", "]", "output_file_path", "=", "self", ".", "actual_arguments", "[", "1", "]", "output_html", "=", "self", ".", "has_option", "(", "u\"--output-html\"", ")", "if", "not", "self", ".", "check_input_file", "(", "input_file_path", ")", ":", "return", "self", ".", "ERROR_EXIT_CODE", "input_sm_format", "=", "self", ".", "has_option_with_value", "(", "u\"--input-format\"", ")", "if", "input_sm_format", "is", "None", ":", "input_sm_format", "=", "gf", ".", "file_extension", "(", "input_file_path", ")", "if", "not", "self", ".", "check_format", "(", "input_sm_format", ")", ":", "return", "self", ".", "ERROR_EXIT_CODE", "if", "not", "self", ".", "check_output_file", "(", "output_file_path", ")", ":", "return", "self", ".", "ERROR_EXIT_CODE", "if", "output_html", ":", "if", "len", "(", "self", ".", "actual_arguments", ")", "<", "3", ":", "return", "self", ".", "print_help", "(", ")", "audio_file_path", "=", "self", ".", "actual_arguments", "[", "2", "]", "if", "not", "self", ".", "check_input_file", "(", "audio_file_path", ")", ":", "return", "self", ".", "ERROR_EXIT_CODE", "else", ":", "output_sm_format", "=", "self", ".", "has_option_with_value", "(", "u\"--output-format\"", ")", "if", "output_sm_format", "is", "None", ":", "output_sm_format", "=", "gf", ".", "file_extension", "(", "output_file_path", ")", "if", "not", "self", ".", "check_format", "(", "output_sm_format", ")", ":", "return", "self", ".", "ERROR_EXIT_CODE", "# TODO add a way to specify a text file for input formats like SMIL", "# that do not carry the source text", "language", "=", "self", ".", "has_option_with_value", "(", "u\"--language\"", ")", "audio_ref", "=", "self", ".", "has_option_with_value", "(", "u\"--audio-ref\"", ")", "page_ref", "=", "self", ".", "has_option_with_value", "(", "u\"--page-ref\"", ")", "parameters", "=", "{", "gc", ".", "PPN_SYNCMAP_LANGUAGE", ":", "language", ",", "gc", ".", "PPN_TASK_OS_FILE_SMIL_AUDIO_REF", ":", "audio_ref", ",", "gc", ".", "PPN_TASK_OS_FILE_SMIL_PAGE_REF", ":", "page_ref", "}", "try", ":", "self", ".", "print_info", "(", "u\"Reading sync map in '%s' format from file '%s'\"", "%", "(", "input_sm_format", ",", "input_file_path", ")", ")", "self", ".", "print_info", "(", "u\"Reading sync map...\"", ")", "syncmap", "=", "SyncMap", "(", "logger", "=", "self", ".", "logger", ")", "syncmap", ".", "read", "(", "input_sm_format", ",", "input_file_path", ",", "parameters", ")", "self", ".", "print_info", "(", "u\"Reading sync map... done\"", ")", "self", ".", "print_info", "(", "u\"Read %d sync map fragments\"", "%", "(", "len", "(", "syncmap", ")", ")", ")", "except", "Exception", "as", "exc", ":", "self", ".", "print_error", "(", "u\"An unexpected error occurred while reading the input sync map:\"", ")", "self", ".", "print_error", "(", "u\"%s\"", "%", "(", "exc", ")", ")", "return", "self", ".", "ERROR_EXIT_CODE", "if", "output_html", ":", "try", ":", "self", ".", "print_info", "(", "u\"Writing HTML file...\"", ")", "syncmap", ".", "output_html_for_tuning", "(", "audio_file_path", ",", "output_file_path", ",", "parameters", ")", "self", ".", "print_info", "(", "u\"Writing HTML file... done\"", ")", "self", ".", "print_success", "(", "u\"Created HTML file '%s'\"", "%", "(", "output_file_path", ")", ")", "return", "self", ".", "NO_ERROR_EXIT_CODE", "except", "Exception", "as", "exc", ":", "self", ".", "print_error", "(", "u\"An unexpected error occurred while writing the output HTML file:\"", ")", "self", ".", "print_error", "(", "u\"%s\"", "%", "(", "exc", ")", ")", "else", ":", "try", ":", "self", ".", "print_info", "(", "u\"Writing sync map...\"", ")", "syncmap", ".", "write", "(", "output_sm_format", ",", "output_file_path", ",", "parameters", ")", "self", ".", "print_info", "(", "u\"Writing sync map... done\"", ")", "self", ".", "print_success", "(", "u\"Created '%s' sync map file '%s'\"", "%", "(", "output_sm_format", ",", "output_file_path", ")", ")", "return", "self", ".", "NO_ERROR_EXIT_CODE", "except", "Exception", "as", "exc", ":", "self", ".", "print_error", "(", "u\"An unexpected error occurred while writing the output sync map:\"", ")", "self", ".", "print_error", "(", "u\"%s\"", "%", "(", "exc", ")", ")", "return", "self", ".", "ERROR_EXIT_CODE" ]

[ "Perform", "command", "and", "return", "the", "appropriate", "exit", "code", "." ]

[ "def", "step", "(", "self", ",", "closure", "=", "None", ")", ":", "loss", "=", "None", "if", "closure", "is", "not", "None", ":", "loss", "=", "closure", "(", ")", "for", "group", "in", "self", ".", "param_groups", ":", "for", "p", "in", "group", "[", "'params'", "]", ":", "if", "p", ".", "grad", "is", "None", ":", "continue", "grad", "=", "p", ".", "grad", ".", "data", "if", "grad", ".", "is_sparse", ":", "raise", "RuntimeError", "(", "'RMSprop does not support sparse gradients'", ")", "state", "=", "self", ".", "state", "[", "p", "]", "# State initialization", "if", "len", "(", "state", ")", "==", "0", ":", "state", "[", "'step'", "]", "=", "0", "# ANOTHER LINE I'VE CHANGED", "state", "[", "'square_avg'", "]", "=", "torch", ".", "ones_like", "(", "p", ".", "data", ")", "if", "group", "[", "'momentum'", "]", ">", "0", ":", "state", "[", "'momentum_buffer'", "]", "=", "torch", ".", "zeros_like", "(", "p", ".", "data", ")", "if", "group", "[", "'centered'", "]", ":", "state", "[", "'grad_avg'", "]", "=", "torch", ".", "zeros_like", "(", "p", ".", "data", ")", "square_avg", "=", "state", "[", "'square_avg'", "]", "alpha", "=", "group", "[", "'alpha'", "]", "state", "[", "'step'", "]", "+=", "1", "if", "group", "[", "'weight_decay'", "]", "!=", "0", ":", "grad", "=", "grad", ".", "add", "(", "group", "[", "'weight_decay'", "]", ",", "p", ".", "data", ")", "square_avg", ".", "mul_", "(", "alpha", ")", ".", "addcmul_", "(", "1", "-", "alpha", ",", "grad", ",", "grad", ")", "if", "group", "[", "'centered'", "]", ":", "grad_avg", "=", "state", "[", "'grad_avg'", "]", "grad_avg", ".", "mul_", "(", "alpha", ")", ".", "add_", "(", "1", "-", "alpha", ",", "grad", ")", "# THIS LINE IS EVERYTHING THAT I CHANGED IN THIS OPTIMIZER", "# avg = square_avg.addcmul(-1, grad_avg, grad_avg).sqrt().add_(group['eps'])", "avg", "=", "square_avg", ".", "addcmul", "(", "-", "1", ",", "grad_avg", ",", "grad_avg", ")", ".", "add", "(", "group", "[", "'eps'", "]", ")", ".", "sqrt", "(", ")", "else", ":", "# THIS LINE IS EVERYTHING THAT I CHANGED IN THIS OPTIMIZER", "# avg = square_avg.sqrt().add_(group['eps'])", "avg", "=", "square_avg", ".", "add", "(", "group", "[", "'eps'", "]", ")", ".", "sqrt", "(", ")", "if", "group", "[", "'momentum'", "]", ">", "0", ":", "buf", "=", "state", "[", "'momentum_buffer'", "]", "buf", ".", "mul_", "(", "group", "[", "'momentum'", "]", ")", ".", "addcdiv_", "(", "grad", ",", "avg", ")", "p", ".", "data", ".", "add_", "(", "-", "group", "[", "'lr'", "]", ",", "buf", ")", "else", ":", "p", ".", "data", ".", "addcdiv_", "(", "-", "group", "[", "'lr'", "]", ",", "grad", ",", "avg", ")", "return", "loss" ]

[ "Performs", "a", "single", "optimization", "step", "." ]

[ "def", "jacobian", "(", "fun", ",", "x", ")", ":", "vjp", ",", "ans", "=", "_make_vjp", "(", "fun", ",", "x", ")", "ans_vspace", "=", "vspace", "(", "ans", ")", "jacobian_shape", "=", "ans_vspace", ".", "shape", "+", "vspace", "(", "x", ")", ".", "shape", "grads", "=", "map", "(", "vjp", ",", "ans_vspace", ".", "standard_basis", "(", ")", ")", "return", "np", ".", "reshape", "(", "np", ".", "stack", "(", "grads", ")", ",", "jacobian_shape", ")" ]

[ "Returns", "a", "function", "which", "computes", "the", "Jacobian", "of", "fun", "with", "respect", "to", "positional", "argument", "number", "argnum", "which", "must", "be", "a", "scalar", "or", "array", ".", "Unlike", "grad", "it", "is", "not", "restricted", "to", "scalar", "-", "output", "functions", "but", "also", "it", "cannot", "take", "derivatives", "with", "respect", "to", "some", "argument", "types", "(", "like", "lists", "or", "dicts", ")", ".", "If", "the", "input", "to", "fun", "has", "shape", "(", "in1", "in2", "...", ")", "and", "the", "output", "has", "shape", "(", "out1", "out2", "...", ")", "then", "the", "Jacobian", "has", "shape", "(", "out1", "out2", "...", "in1", "in2", "...", ")", "." ]

[ "def", "_upper", "(", "val_list", ")", ":", "res", "=", "[", "]", "for", "ele", "in", "val_list", ":", "res", ".", "append", "(", "ele", ".", "upper", "(", ")", ")", "return", "res" ]

[ ":", "param", "val_list", ":", "a", "list", "of", "strings", ":", "return", ":", "a", "list", "of", "upper", "-", "cased", "strings" ]

[ "def", "get_sequence", "(", "self", ",", "ref", ")", ":", "strand", "=", "'+'", "if", "not", "self", ".", "_options", ".", "direction", ":", "sys", ".", "stderr", ".", "write", "(", "\"WARNING: no strand information for the transcript\\n\"", ")", "if", "self", ".", "_options", ".", "direction", ":", "strand", "=", "self", ".", "_options", ".", "direction", "seq", "=", "''", "for", "e", "in", "[", "x", ".", "range", "for", "x", "in", "self", ".", "exons", "]", ":", "seq", "+=", "str", "(", "ref", "[", "e", ".", "chr", "]", "[", "e", ".", "start", "-", "1", ":", "e", ".", "end", "]", ")", "if", "strand", "==", "'-'", ":", "seq", "=", "rc", "(", "seq", ")", "return", "Sequence", "(", "seq", ".", "upper", "(", ")", ")" ]

[ "get", "a", "sequence", "given", "a", "reference" ]

[ "def", "avail_images", "(", "call", "=", "None", ")", ":", "if", "call", "==", "'action'", ":", "raise", "SaltCloudSystemExit", "(", "'The avail_images function must be called with '", "'-f or --function, or with the --list-images option'", ")", "compconn", "=", "get_conn", "(", "client_type", "=", "'compute'", ")", "region", "=", "get_location", "(", ")", "publishers", "=", "[", "]", "ret", "=", "{", "}", "def", "_get_publisher_images", "(", "publisher", ")", ":", "'''\n Get all images from a specific publisher\n '''", "data", "=", "{", "}", "try", ":", "offers", "=", "compconn", ".", "virtual_machine_images", ".", "list_offers", "(", "location", "=", "region", ",", "publisher_name", "=", "publisher", ",", ")", "for", "offer_obj", "in", "offers", ":", "offer", "=", "offer_obj", ".", "as_dict", "(", ")", "skus", "=", "compconn", ".", "virtual_machine_images", ".", "list_skus", "(", "location", "=", "region", ",", "publisher_name", "=", "publisher", ",", "offer", "=", "offer", "[", "'name'", "]", ",", ")", "for", "sku_obj", "in", "skus", ":", "sku", "=", "sku_obj", ".", "as_dict", "(", ")", "results", "=", "compconn", ".", "virtual_machine_images", ".", "list", "(", "location", "=", "region", ",", "publisher_name", "=", "publisher", ",", "offer", "=", "offer", "[", "'name'", "]", ",", "skus", "=", "sku", "[", "'name'", "]", ",", ")", "for", "version_obj", "in", "results", ":", "version", "=", "version_obj", ".", "as_dict", "(", ")", "name", "=", "'|'", ".", "join", "(", "(", "publisher", ",", "offer", "[", "'name'", "]", ",", "sku", "[", "'name'", "]", ",", "version", "[", "'name'", "]", ",", ")", ")", "data", "[", "name", "]", "=", "{", "'publisher'", ":", "publisher", ",", "'offer'", ":", "offer", "[", "'name'", "]", ",", "'sku'", ":", "sku", "[", "'name'", "]", ",", "'version'", ":", "version", "[", "'name'", "]", ",", "}", "except", "CloudError", "as", "exc", ":", "__utils__", "[", "'azurearm.log_cloud_error'", "]", "(", "'compute'", ",", "exc", ".", "message", ")", "data", "=", "{", "publisher", ":", "exc", ".", "message", "}", "return", "data", "try", ":", "publishers_query", "=", "compconn", ".", "virtual_machine_images", ".", "list_publishers", "(", "location", "=", "region", ")", "for", "publisher_obj", "in", "publishers_query", ":", "publisher", "=", "publisher_obj", ".", "as_dict", "(", ")", "publishers", ".", "append", "(", "publisher", "[", "'name'", "]", ")", "except", "CloudError", "as", "exc", ":", "__utils__", "[", "'azurearm.log_cloud_error'", "]", "(", "'compute'", ",", "exc", ".", "message", ")", "pool", "=", "ThreadPool", "(", "cpu_count", "(", ")", "*", "6", ")", "results", "=", "pool", ".", "map_async", "(", "_get_publisher_images", ",", "publishers", ")", "results", ".", "wait", "(", ")", "ret", "=", "{", "k", ":", "v", "for", "result", "in", "results", ".", "get", "(", ")", "for", "k", ",", "v", "in", "six", ".", "iteritems", "(", "result", ")", "}", "return", "ret" ]

[ "Return", "a", "dict", "of", "all", "available", "images", "on", "the", "provider" ]

[ "def", "start", "(", "cls", ",", "callback", ",", "provider", "=", "'gps'", ",", "min_time", "=", "1000", ",", "min_distance", "=", "0", ")", ":", "app", "=", "AndroidApplication", ".", "instance", "(", ")", "f", "=", "app", ".", "create_future", "(", ")", "def", "on_success", "(", "lm", ")", ":", "#: When we have finally have permission", "lm", ".", "onLocationChanged", ".", "connect", "(", "callback", ")", "#: Save a reference to our listener", "#: because we may want to stop updates", "listener", "=", "LocationManager", ".", "LocationListener", "(", "lm", ")", "lm", ".", "listeners", ".", "append", "(", "listener", ")", "lm", ".", "requestLocationUpdates", "(", "provider", ",", "min_time", ",", "min_distance", ",", "listener", ")", "app", ".", "set_future_result", "(", "f", ",", "True", ")", "def", "on_perm_request_result", "(", "allowed", ")", ":", "#: When our permission request is accepted or decliend.", "if", "allowed", ":", "LocationManager", ".", "get", "(", ")", ".", "then", "(", "on_success", ")", "else", ":", "#: Access denied", "app", ".", "set_future_result", "(", "f", ",", "False", ")", "def", "on_perm_check", "(", "allowed", ")", ":", "if", "allowed", ":", "LocationManager", ".", "get", "(", ")", ".", "then", "(", "on_success", ")", "else", ":", "LocationManager", ".", "request_permission", "(", "fine", "=", "provider", "==", "'gps'", ")", ".", "then", "(", "on_perm_request_result", ")", "#: Check permission", "LocationManager", ".", "check_permission", "(", "fine", "=", "provider", "==", "'gps'", ")", ".", "then", "(", "on_perm_check", ")", "return", "f" ]

[ "Convenience", "method", "that", "checks", "and", "requests", "permission", "if", "necessary", "and", "if", "successful", "calls", "the", "callback", "with", "a", "populated", "Location", "instance", "on", "updates", "." ]

[ "def", "dispatch_request", "(", "self", ")", ":", "req", "=", "_request_ctx_stack", ".", "top", ".", "request", "if", "req", ".", "routing_exception", "is", "not", "None", ":", "self", ".", "raise_routing_exception", "(", "req", ")", "rule", "=", "req", ".", "url_rule", "# if we provide automatic options for this URL and the", "# request came with the OPTIONS method, reply automatically", "if", "getattr", "(", "rule", ",", "'provide_automatic_options'", ",", "False", ")", "and", "req", ".", "method", "==", "'OPTIONS'", ":", "return", "self", ".", "make_default_options_response", "(", ")", "# otherwise dispatch to the handler for that endpoint", "return", "self", ".", "view_functions", "[", "rule", ".", "endpoint", "]", "(", "*", "*", "req", ".", "view_args", ")" ]

[ "Does", "the", "request", "dispatching", ".", "Matches", "the", "URL", "and", "returns", "the", "return", "value", "of", "the", "view", "or", "error", "handler", ".", "This", "does", "not", "have", "to", "be", "a", "response", "object", ".", "In", "order", "to", "convert", "the", "return", "value", "to", "a", "proper", "response", "object", "call", ":", "func", ":", "make_response", "." ]

[ "def", "_recSortKey", "(", "r", ")", ":", "return", "r", ".", "seqname", ",", "r", ".", "start", ",", "-", "r", ".", "end", ",", "r", ".", "type" ]

[ "Sort", "order", "for", "Features", "by", "genomic", "coordinate", "disambiguated", "by", "feature", "type", "(", "alphabetically", ")", "." ]

[ "def", "check_file_ids", "(", "self", ",", "rawfiles", ",", "cellpyfile", ")", ":", "txt", "=", "\"checking file ids - using '%s'\"", "%", "self", ".", "filestatuschecker", "self", ".", "logger", ".", "info", "(", "txt", ")", "ids_cellpy_file", "=", "self", ".", "_check_cellpy_file", "(", "cellpyfile", ")", "self", ".", "logger", ".", "debug", "(", "f\"cellpyfile ids: {ids_cellpy_file}\"", ")", "if", "not", "ids_cellpy_file", ":", "# self.logger.debug(\"hdf5 file does not exist - needs updating\")", "return", "False", "ids_raw", "=", "self", ".", "_check_raw", "(", "rawfiles", ")", "similar", "=", "self", ".", "_compare_ids", "(", "ids_raw", ",", "ids_cellpy_file", ")", "if", "not", "similar", ":", "# self.logger.debug(\"hdf5 file needs updating\")", "return", "False", "else", ":", "# self.logger.debug(\"hdf5 file is updated\")", "return", "True" ]

[ "Check", "the", "stats", "for", "the", "files", "(", "raw", "-", "data", "and", "cellpy", "hdf5", ")", "." ]

[ "def", "close_right", "(", "self", ")", ":", "current_widget", "=", "self", ".", "widget", "(", "self", ".", "tab_under_menu", "(", ")", ")", "index", "=", "self", ".", "indexOf", "(", "current_widget", ")", "if", "self", ".", "_try_close_dirty_tabs", "(", "tab_range", "=", "range", "(", "index", "+", "1", ",", "self", ".", "count", "(", ")", ")", ")", ":", "while", "True", ":", "widget", "=", "self", ".", "widget", "(", "self", ".", "count", "(", ")", "-", "1", ")", "if", "widget", "!=", "current_widget", ":", "self", ".", "remove_tab", "(", "self", ".", "count", "(", ")", "-", "1", ")", "else", ":", "break" ]

[ "Closes", "every", "editors", "tabs", "on", "the", "left", "of", "the", "current", "one", "." ]

[ "def", "input_list_parser", "(", "infile_list", ")", ":", "final_list_of_files", "=", "[", "]", "for", "x", "in", "infile_list", ":", "# If the input is a folder", "if", "op", ".", "isdir", "(", "x", ")", ":", "os", ".", "chdir", "(", "x", ")", "final_list_of_files", ".", "extend", "(", "glob", ".", "glob", "(", "'*'", ")", ")", "# If the input is a file", "if", "op", ".", "isfile", "(", "x", ")", ":", "final_list_of_files", ".", "append", "(", "x", ")", "return", "final_list_of_files" ]

[ "Always", "return", "a", "list", "of", "files", "with", "varying", "input", "." ]

[ "def", "disconnect", "(", "remote", ")", ":", "# User must be authenticated", "if", "not", "current_user", ".", "is_authenticated", ":", "return", "current_app", ".", "login_manager", ".", "unauthorized", "(", ")", "external_method", "=", "'github'", "external_ids", "=", "[", "i", ".", "id", "for", "i", "in", "current_user", ".", "external_identifiers", "if", "i", ".", "method", "==", "external_method", "]", "if", "external_ids", ":", "oauth_unlink_external_id", "(", "dict", "(", "id", "=", "external_ids", "[", "0", "]", ",", "method", "=", "external_method", ")", ")", "user_id", "=", "int", "(", "current_user", ".", "get_id", "(", ")", ")", "token", "=", "RemoteToken", ".", "get", "(", "user_id", ",", "remote", ".", "consumer_key", ")", "if", "token", ":", "extra_data", "=", "token", ".", "remote_account", ".", "extra_data", "# Delete the token that we issued for GitHub to deliver webhooks", "webhook_token_id", "=", "extra_data", ".", "get", "(", "'tokens'", ",", "{", "}", ")", ".", "get", "(", "'webhook'", ")", "ProviderToken", ".", "query", ".", "filter_by", "(", "id", "=", "webhook_token_id", ")", ".", "delete", "(", ")", "# Disable GitHub webhooks from our side", "db_repos", "=", "Repository", ".", "query", ".", "filter_by", "(", "user_id", "=", "user_id", ")", ".", "all", "(", ")", "# Keep repositories with hooks to pass to the celery task later on", "repos_with_hooks", "=", "[", "(", "r", ".", "github_id", ",", "r", ".", "hook", ")", "for", "r", "in", "db_repos", "if", "r", ".", "hook", "]", "for", "repo", "in", "db_repos", ":", "try", ":", "Repository", ".", "disable", "(", "user_id", "=", "user_id", ",", "github_id", "=", "repo", ".", "github_id", ",", "name", "=", "repo", ".", "name", ")", "except", "NoResultFound", ":", "# If the repository doesn't exist, no action is necessary", "pass", "db", ".", "session", ".", "commit", "(", ")", "# Send Celery task for webhooks removal and token revocation", "disconnect_github", ".", "delay", "(", "token", ".", "access_token", ",", "repos_with_hooks", ")", "# Delete the RemoteAccount (along with the associated RemoteToken)", "token", ".", "remote_account", ".", "delete", "(", ")", "return", "redirect", "(", "url_for", "(", "'invenio_oauthclient_settings.index'", ")", ")" ]

[ "Disconnect", "callback", "handler", "for", "GitHub", "." ]

[ "def", "set_max_string_length", "(", "self", ",", "length", "=", "None", ")", ":", "if", "self", ".", "get_max_string_length_metadata", "(", ")", ".", "is_read_only", "(", ")", ":", "raise", "NoAccess", "(", ")", "if", "not", "self", ".", "my_osid_object_form", ".", "_is_valid_cardinal", "(", "length", ",", "self", ".", "get_max_string_length_metadata", "(", ")", ")", ":", "raise", "InvalidArgument", "(", ")", "if", "self", ".", "my_osid_object_form", ".", "min_string_length", "is", "not", "None", "and", "length", "<", "self", ".", "my_osid_object_form", ".", "min_string_length", "+", "1", ":", "raise", "InvalidArgument", "(", ")", "self", ".", "my_osid_object_form", ".", "_my_map", "[", "'maxStringLength'", "]", "=", "length", "self", ".", "_max_string_length", "=", "length" ]

[ "stub" ]

[ "def", "compile_authors", "(", "cell", ")", ":", "logger_excel", ".", "info", "(", "\"enter compile_authors\"", ")", "author_lst", "=", "[", "]", "s", "=", "cell", ".", "split", "(", "';'", ")", "for", "w", "in", "s", ":", "author_lst", ".", "append", "(", "w", ".", "lstrip", "(", ")", ")", "logger_excel", ".", "info", "(", "\"exit compile_authors\"", ")", "return", "author_lst" ]

[ "Split", "the", "string", "of", "author", "names", "into", "the", "BibJSON", "format", ".", ":", "param", "str", "cell", ":", "Data", "from", "author", "cell", ":", "return", ":", "(", "list", "of", "dicts", ")", "Author", "names" ]

[ "def", "set_handler", "(", "self", ",", "handler", ",", "start_heartbeat", "=", "True", ")", ":", "# Check if session already has associated handler", "if", "self", ".", "handler", "is", "not", "None", ":", "handler", ".", "send_pack", "(", "proto", ".", "disconnect", "(", "2010", ",", "\"Another connection still open\"", ")", ")", "return", "False", "if", "self", ".", "_verify_ip", "and", "self", ".", "conn_info", "is", "not", "None", ":", "# If IP address doesn't match - refuse connection", "if", "handler", ".", "request", ".", "remote_ip", "!=", "self", ".", "conn_info", ".", "ip", ":", "LOG", ".", "error", "(", "'Attempted to attach to session %s (%s) from different IP (%s)'", "%", "(", "self", ".", "session_id", ",", "self", ".", "conn_info", ".", "ip", ",", "handler", ".", "request", ".", "remote_ip", ")", ")", "handler", ".", "send_pack", "(", "proto", ".", "disconnect", "(", "2010", ",", "\"Attempted to connect to session from different IP\"", ")", ")", "return", "False", "if", "(", "self", ".", "state", "==", "CLOSING", "or", "self", ".", "state", "==", "CLOSED", ")", "and", "not", "self", ".", "send_queue", ":", "handler", ".", "send_pack", "(", "proto", ".", "disconnect", "(", "*", "self", ".", "get_close_reason", "(", ")", ")", ")", "return", "False", "# Associate handler and promote session", "super", "(", "Session", ",", "self", ")", ".", "set_handler", "(", "handler", ")", "self", ".", "promote", "(", ")", "if", "start_heartbeat", ":", "self", ".", "start_heartbeat", "(", ")", "return", "True" ]

[ "Set", "active", "handler", "for", "the", "session" ]

[ "def", "get_top_tags", "(", "self", ",", "limit", "=", "None", ")", ":", "doc", "=", "self", ".", "_request", "(", "self", ".", "ws_prefix", "+", "\".getTopTags\"", ",", "True", ")", "elements", "=", "doc", ".", "getElementsByTagName", "(", "\"tag\"", ")", "seq", "=", "[", "]", "for", "element", "in", "elements", ":", "tag_name", "=", "_extract", "(", "element", ",", "\"name\"", ")", "tagcount", "=", "_extract", "(", "element", ",", "\"count\"", ")", "seq", ".", "append", "(", "TopItem", "(", "Tag", "(", "tag_name", ",", "self", ".", "network", ")", ",", "tagcount", ")", ")", "if", "limit", ":", "seq", "=", "seq", "[", ":", "limit", "]", "return", "seq" ]

[ "Returns", "a", "list", "of", "the", "most", "frequently", "used", "Tags", "on", "this", "object", "." ]

[ "def", "delete", "(", "self", ",", "*", "*", "kwds", ")", ":", "result", "=", "self", ".", "_client", ".", "photo", ".", "delete", "(", "self", ",", "*", "*", "kwds", ")", "self", ".", "_delete_fields", "(", ")", "return", "result" ]

[ "Endpoint", ":", "/", "photo", "/", "<id", ">", "/", "delete", ".", "json" ]

[ "def", "append_children", "(", "self", ",", "content", ")", ":", "for", "child", "in", "content", ".", "node", ":", "cont", "=", "Content", "(", "child", ")", "cval", "=", "self", ".", "append", "(", "cont", ")", "key", "=", "reserved", ".", "get", "(", "child", ".", "name", ",", "child", ".", "name", ")", "if", "key", "in", "content", ".", "data", ":", "v", "=", "getattr", "(", "content", ".", "data", ",", "key", ")", "if", "isinstance", "(", "v", ",", "list", ")", ":", "v", ".", "append", "(", "cval", ")", "else", ":", "setattr", "(", "content", ".", "data", ",", "key", ",", "[", "v", ",", "cval", "]", ")", "continue", "if", "self", ".", "multi_occurrence", "(", "cont", ")", ":", "if", "cval", "is", "None", ":", "setattr", "(", "content", ".", "data", ",", "key", ",", "[", "]", ")", "else", ":", "setattr", "(", "content", ".", "data", ",", "key", ",", "[", "cval", ",", "]", ")", "else", ":", "setattr", "(", "content", ".", "data", ",", "key", ",", "cval", ")" ]

[ "Append", "child", "nodes", "into", "L", "{", "Content", ".", "data", "}" ]

[ "def", "resource_type", "(", "self", ")", ":", "value", "=", "\"rt=\"", "lst", "=", "self", ".", "_attributes", ".", "get", "(", "\"rt\"", ")", "if", "lst", "is", "None", ":", "value", "=", "\"\"", "else", ":", "value", "+=", "\"\\\"\"", "+", "str", "(", "lst", ")", "+", "\"\\\"\"", "return", "value" ]

[ "Get", "the", "CoRE", "Link", "Format", "rt", "attribute", "of", "the", "resource", "." ]

[ "def", "_get_min_distance_to_volcanic_front", "(", "lons", ",", "lats", ")", ":", "vf", "=", "_construct_surface", "(", "VOLCANIC_FRONT_LONS", ",", "VOLCANIC_FRONT_LATS", ",", "0.", ",", "10.", ")", "sites", "=", "Mesh", "(", "lons", ",", "lats", ",", "None", ")", "return", "vf", ".", "get_rx_distance", "(", "sites", ")" ]

[ "Compute", "and", "return", "minimum", "distance", "between", "volcanic", "front", "and", "points", "specified", "by", "lon", "and", "lat", "." ]

[ "def", "_get_template_text_from_package", "(", "self", ",", "template_name", ")", ":", "if", "self", ".", "_package_name", "is", "None", ":", "raise", "self", ".", "MustacheError", "(", "'No package specified for template loading.'", ")", "path", "=", "os", ".", "path", ".", "join", "(", "'templates'", ",", "template_name", "+", "'.mustache'", ")", "template_text", "=", "pkgutil", ".", "get_data", "(", "self", ".", "_package_name", ",", "path", ")", "if", "template_text", "is", "None", ":", "raise", "self", ".", "MustacheError", "(", "'could not find template {} in package {}'", ".", "format", "(", "path", ",", "self", ".", "_package_name", ")", ")", "return", "template_text", ".", "decode", "(", "'utf8'", ")" ]

[ "Load", "the", "named", "template", "embedded", "in", "our", "package", "." ]

[ "def", "children_sum", "(", "self", ",", "children", ",", "node", ")", ":", "return", "sum", "(", "[", "self", ".", "value", "(", "value", ",", "node", ")", "for", "value", "in", "children", "]", ")" ]

[ "Calculate", "children", "s", "total", "sum" ]

[ "def", "get_project_items", "(", "pronac", ")", ":", "df", "=", "data", ".", "all_items", "return", "(", "df", "[", "df", "[", "'PRONAC'", "]", "==", "pronac", "]", ".", "drop", "(", "columns", "=", "[", "'PRONAC'", ",", "'idSegmento'", "]", ")", ")" ]

[ "Returns", "all", "items", "from", "a", "project", "." ]

[ "def", "_wait_for_save", "(", "nb_name", ",", "timeout", "=", "5", ")", ":", "modification_time", "=", "os", ".", "path", ".", "getmtime", "(", "nb_name", ")", "start_time", "=", "time", ".", "time", "(", ")", "while", "time", ".", "time", "(", ")", "<", "start_time", "+", "timeout", ":", "if", "(", "os", ".", "path", ".", "getmtime", "(", "nb_name", ")", ">", "modification_time", "and", "os", ".", "path", ".", "getsize", "(", "nb_name", ")", ">", "0", ")", ":", "return", "True", "time", ".", "sleep", "(", "0.2", ")", "return", "False" ]

[ "Waits", "for", "nb_name", "to", "update", "waiting", "up", "to", "TIMEOUT", "seconds", ".", "Returns", "True", "if", "a", "save", "was", "detected", "and", "False", "otherwise", "." ]

[ "def", "flush_incoming", "(", "self", ")", ":", "while", "True", ":", "try", ":", "stanza_obj", "=", "self", ".", "_incoming_queue", ".", "get_nowait", "(", ")", "except", "asyncio", ".", "QueueEmpty", ":", "break", "self", ".", "_process_incoming", "(", "None", ",", "stanza_obj", ")" ]

[ "Flush", "all", "incoming", "queues", "to", "the", "respective", "processing", "methods", ".", "The", "handlers", "are", "called", "as", "usual", "thus", "it", "may", "require", "at", "least", "one", "iteration", "through", "the", "asyncio", "event", "loop", "before", "effects", "can", "be", "seen", "." ]

[ "def", "array_has_real_numbers", "(", "array", ")", ":", "kind", "=", "array", ".", "dtype", ".", "kind", "assert", "kind", "in", "'biufcmMOSUV'", ",", "\"Unexpected array kind: {}\"", ".", "format", "(", "kind", ")", "return", "kind", "in", "'iuf'" ]

[ "Uses", "the", "dtype", "kind", "of", "the", "numpy", "array", "to", "determine", "if", "it", "represents", "real", "numbers", "." ]

[ "def", "sort", "(", "self", ",", "*", "args", ")", ":", "self", ".", "valid", ".", "sort", "(", "*", "args", ")", "self", ".", "active", ".", "sort", "(", "*", "args", ")" ]

[ "Sort", "the", "internal", "segment", "lists", ".", "The", "optional", "args", "are", "passed", "to", "the", ".", "sort", "()", "method", "of", "the", "segment", "lists", ".", "This", "can", "be", "used", "to", "control", "the", "sort", "order", "by", "providing", "an", "alternate", "comparison", "function", ".", "The", "default", "is", "to", "sort", "by", "start", "time", "with", "ties", "broken", "by", "end", "time", "." ]

[ "def", "loadLayerNoCrsDialog", "(", "filename", ",", "name", "=", "None", ",", "provider", "=", "None", ")", ":", "settings", "=", "QSettings", "(", ")", "prjSetting", "=", "settings", ".", "value", "(", "'/Projections/defaultBehaviour'", ")", "settings", ".", "setValue", "(", "'/Projections/defaultBehaviour'", ",", "''", ")", "# QGIS3:", "prjSetting3", "=", "settings", ".", "value", "(", "'/Projections/defaultBehavior'", ")", "settings", ".", "setValue", "(", "'/Projections/defaultBehavior'", ",", "''", ")", "layer", "=", "loadLayer", "(", "filename", ",", "name", ",", "provider", ")", "settings", ".", "setValue", "(", "'/Projections/defaultBehaviour'", ",", "prjSetting", ")", "settings", ".", "setValue", "(", "'/Projections/defaultBehavior'", ",", "prjSetting3", ")", "return", "layer" ]

[ "Tries", "to", "load", "a", "layer", "from", "the", "given", "file", "Same", "as", "the", "loadLayer", "method", "but", "it", "does", "not", "ask", "for", "CRS", "regardless", "of", "current", "configuration", "in", "QGIS", "settings" ]

[ "def", "read_exports", "(", "self", ")", ":", "result", "=", "{", "}", "r", "=", "self", ".", "get_distinfo_resource", "(", "EXPORTS_FILENAME", ")", "if", "r", ":", "with", "contextlib", ".", "closing", "(", "r", ".", "as_stream", "(", ")", ")", "as", "stream", ":", "result", "=", "read_exports", "(", "stream", ")", "return", "result" ]

[ "Read", "exports", "data", "from", "a", "file", "in", ".", "ini", "format", "." ]

[ "def", "list", "(", "self", ",", "out", "=", "sys", ".", "stdout", ")", ":", "out", ".", "write", "(", "'-- listing properties --\\n'", ")", "for", "key", ",", "value", "in", "self", ".", "_properties", ".", "items", "(", ")", ":", "out", ".", "write", "(", "''", ".", "join", "(", "(", "key", ",", "'='", ",", "value", ",", "'\\n'", ")", ")", ")" ]

[ "Prints", "a", "listing", "of", "the", "properties", "to", "the", "stream", "out", "which", "defaults", "to", "the", "standard", "output" ]

[ "def", "set_to_cache", "(", "self", ")", ":", "queryset", "=", "self", ".", "get_queryset", "(", ")", "cache", ".", "set", "(", "self", ".", "_get_cache_key", "(", ")", ",", "{", "'queryset'", ":", "[", "queryset", ".", "none", "(", ")", ",", "queryset", ".", "query", ",", "]", ",", "'cls'", ":", "self", ".", "__class__", ",", "'search_fields'", ":", "tuple", "(", "self", ".", "search_fields", ")", ",", "'max_results'", ":", "int", "(", "self", ".", "max_results", ")", ",", "'url'", ":", "str", "(", "self", ".", "get_url", "(", ")", ")", ",", "'dependent_fields'", ":", "dict", "(", "self", ".", "dependent_fields", ")", ",", "}", ")" ]

[ "Add", "widget", "s", "attributes", "to", "Django", "s", "cache", "." ]

[ "def", "API_GET", "(", "self", ",", "courseid", "=", "None", ")", ":", "# pylint: disable=arguments-differ", "output", "=", "[", "]", "if", "courseid", "is", "None", ":", "courses", "=", "self", ".", "course_factory", ".", "get_all_courses", "(", ")", "else", ":", "try", ":", "courses", "=", "{", "courseid", ":", "self", ".", "course_factory", ".", "get_course", "(", "courseid", ")", "}", "except", ":", "raise", "APINotFound", "(", "\"Course not found\"", ")", "username", "=", "self", ".", "user_manager", ".", "session_username", "(", ")", "user_info", "=", "self", ".", "database", ".", "users", ".", "find_one", "(", "{", "\"username\"", ":", "username", "}", ")", "for", "courseid", ",", "course", "in", "courses", ".", "items", "(", ")", ":", "if", "self", ".", "user_manager", ".", "course_is_open_to_user", "(", "course", ",", "username", ",", "False", ")", "or", "course", ".", "is_registration_possible", "(", "user_info", ")", ":", "data", "=", "{", "\"id\"", ":", "courseid", ",", "\"name\"", ":", "course", ".", "get_name", "(", "self", ".", "user_manager", ".", "session_language", "(", ")", ")", ",", "\"require_password\"", ":", "course", ".", "is_password_needed_for_registration", "(", ")", ",", "\"is_registered\"", ":", "self", ".", "user_manager", ".", "course_is_open_to_user", "(", "course", ",", "username", ",", "False", ")", "}", "if", "self", ".", "user_manager", ".", "course_is_open_to_user", "(", "course", ",", "username", ",", "False", ")", ":", "data", "[", "\"tasks\"", "]", "=", "{", "taskid", ":", "task", ".", "get_name", "(", "self", ".", "user_manager", ".", "session_language", "(", ")", ")", "for", "taskid", ",", "task", "in", "course", ".", "get_tasks", "(", ")", ".", "items", "(", ")", "}", "data", "[", "\"grade\"", "]", "=", "self", ".", "user_manager", ".", "get_course_cache", "(", "username", ",", "course", ")", "[", "\"grade\"", "]", "output", ".", "append", "(", "data", ")", "return", "200", ",", "output" ]

[ "List", "courses", "available", "to", "the", "connected", "client", ".", "Returns", "a", "dict", "in", "the", "form" ]

[ "def", "_fix_orig_vcf_refs", "(", "data", ")", ":", "variantcaller", "=", "tz", ".", "get_in", "(", "(", "\"config\"", ",", "\"algorithm\"", ",", "\"variantcaller\"", ")", ",", "data", ")", "if", "variantcaller", ":", "data", "[", "\"vrn_file_orig\"", "]", "=", "data", "[", "\"vrn_file\"", "]", "for", "i", ",", "sub", "in", "enumerate", "(", "data", ".", "get", "(", "\"group_orig\"", ",", "[", "]", ")", ")", ":", "sub_vrn", "=", "sub", ".", "pop", "(", "\"vrn_file\"", ",", "None", ")", "if", "sub_vrn", ":", "sub", "[", "\"vrn_file_orig\"", "]", "=", "sub_vrn", "data", "[", "\"group_orig\"", "]", "[", "i", "]", "=", "sub", "return", "data" ]

[ "Supply", "references", "to", "initial", "variantcalls", "if", "run", "in", "addition", "to", "batching", "." ]

[ "def", "to_file", "(", "package", ",", "directory", ")", ":", "opf_filepath", "=", "os", ".", "path", ".", "join", "(", "directory", ",", "package", ".", "name", ")", "# Create the directory structure", "for", "name", "in", "(", "'contents'", ",", "'resources'", ",", ")", ":", "path", "=", "os", ".", "path", ".", "join", "(", "directory", ",", "name", ")", "if", "not", "os", ".", "path", ".", "exists", "(", "path", ")", ":", "os", ".", "mkdir", "(", "path", ")", "# Write the items to the filesystem", "locations", "=", "{", "}", "# Used when rendering", "for", "item", "in", "package", ":", "if", "item", ".", "media_type", "==", "'application/xhtml+xml'", ":", "base", "=", "os", ".", "path", ".", "join", "(", "directory", ",", "'contents'", ")", "else", ":", "base", "=", "os", ".", "path", ".", "join", "(", "directory", ",", "'resources'", ")", "filename", "=", "item", ".", "name", "filepath", "=", "os", ".", "path", ".", "join", "(", "base", ",", "filename", ")", "locations", "[", "item", "]", "=", "os", ".", "path", ".", "relpath", "(", "filepath", ",", "directory", ")", "with", "open", "(", "filepath", ",", "'wb'", ")", "as", "item_file", ":", "item_file", ".", "write", "(", "item", ".", "data", ".", "read", "(", ")", ")", "# Write the OPF", "template", "=", "jinja2", ".", "Template", "(", "OPF_TEMPLATE", ",", "trim_blocks", "=", "True", ",", "lstrip_blocks", "=", "True", ")", "with", "open", "(", "opf_filepath", ",", "'wb'", ")", "as", "opf_file", ":", "opf", "=", "template", ".", "render", "(", "package", "=", "package", ",", "locations", "=", "locations", ")", "if", "not", "isinstance", "(", "opf", ",", "bytes", ")", ":", "opf", "=", "opf", ".", "encode", "(", "'utf-8'", ")", "opf_file", ".", "write", "(", "opf", ")", "return", "opf_filepath" ]

[ "Write", "the", "package", "to", "the", "given", "directory", ".", "Returns", "the", "OPF", "filename", "." ]

[ "def", "color", "(", "self", ",", "code", ")", ":", "def", "func", "(", "content", "=", "''", ")", ":", "return", "self", ".", "_apply_color", "(", "u'38;5;%d'", "%", "code", ",", "content", ")", "return", "func" ]

[ "When", "color", "is", "given", "as", "a", "number", "apply", "that", "color", "to", "the", "content", "While", "this", "is", "designed", "to", "support", "256", "color", "terminals", "Windows", "will", "approximate", "this", "with", "16", "colors" ]

[ "def", "cluster_sites", "(", "mol", ",", "tol", ",", "give_only_index", "=", "False", ")", ":", "# Cluster works for dim > 2 data. We just add a dummy 0 for second", "# coordinate.", "dists", "=", "[", "[", "np", ".", "linalg", ".", "norm", "(", "site", ".", "coords", ")", ",", "0", "]", "for", "site", "in", "mol", "]", "import", "scipy", ".", "cluster", "as", "spcluster", "f", "=", "spcluster", ".", "hierarchy", ".", "fclusterdata", "(", "dists", ",", "tol", ",", "criterion", "=", "'distance'", ")", "clustered_dists", "=", "defaultdict", "(", "list", ")", "for", "i", ",", "site", "in", "enumerate", "(", "mol", ")", ":", "clustered_dists", "[", "f", "[", "i", "]", "]", ".", "append", "(", "dists", "[", "i", "]", ")", "avg_dist", "=", "{", "label", ":", "np", ".", "mean", "(", "val", ")", "for", "label", ",", "val", "in", "clustered_dists", ".", "items", "(", ")", "}", "clustered_sites", "=", "defaultdict", "(", "list", ")", "origin_site", "=", "None", "for", "i", ",", "site", "in", "enumerate", "(", "mol", ")", ":", "if", "avg_dist", "[", "f", "[", "i", "]", "]", "<", "tol", ":", "if", "give_only_index", ":", "origin_site", "=", "i", "else", ":", "origin_site", "=", "site", "else", ":", "if", "give_only_index", ":", "clustered_sites", "[", "(", "avg_dist", "[", "f", "[", "i", "]", "]", ",", "site", ".", "species", ")", "]", ".", "append", "(", "i", ")", "else", ":", "clustered_sites", "[", "(", "avg_dist", "[", "f", "[", "i", "]", "]", ",", "site", ".", "species", ")", "]", ".", "append", "(", "site", ")", "return", "origin_site", ",", "clustered_sites" ]

[ "Cluster", "sites", "based", "on", "distance", "and", "species", "type", "." ]

[ "def", "_subtract", "(", "summary", ",", "o", ")", ":", "found", "=", "False", "row", "=", "[", "_repr", "(", "o", ")", ",", "1", ",", "_getsizeof", "(", "o", ")", "]", "for", "r", "in", "summary", ":", "if", "r", "[", "0", "]", "==", "row", "[", "0", "]", ":", "(", "r", "[", "1", "]", ",", "r", "[", "2", "]", ")", "=", "(", "r", "[", "1", "]", "-", "row", "[", "1", "]", ",", "r", "[", "2", "]", "-", "row", "[", "2", "]", ")", "found", "=", "True", "if", "not", "found", ":", "summary", ".", "append", "(", "[", "row", "[", "0", "]", ",", "-", "row", "[", "1", "]", ",", "-", "row", "[", "2", "]", "]", ")", "return", "summary" ]

[ "Remove", "object", "o", "from", "the", "summary", "by", "subtracting", "it", "s", "size", "." ]

[ "def", "update", "(", "self", ",", "milliseconds", ")", ":", "self", ".", "__sort_up", "(", ")", "for", "obj", "in", "self", ".", "__up_objects", ":", "obj", ".", "update", "(", "milliseconds", ")" ]

[ "Updates", "all", "of", "the", "objects", "in", "our", "world", "." ]

[ "def", "get_value", "(", "self", ",", "sid", ",", "dt", ",", "field", ")", ":", "if", "self", ".", "_last_get_value_dt_value", "==", "dt", ".", "value", ":", "minute_pos", "=", "self", ".", "_last_get_value_dt_position", "else", ":", "try", ":", "minute_pos", "=", "self", ".", "_find_position_of_minute", "(", "dt", ")", "except", "ValueError", ":", "raise", "NoDataOnDate", "(", ")", "self", ".", "_last_get_value_dt_value", "=", "dt", ".", "value", "self", ".", "_last_get_value_dt_position", "=", "minute_pos", "try", ":", "value", "=", "self", ".", "_open_minute_file", "(", "field", ",", "sid", ")", "[", "minute_pos", "]", "except", "IndexError", ":", "value", "=", "0", "if", "value", "==", "0", ":", "if", "field", "==", "'volume'", ":", "return", "0", "else", ":", "return", "np", ".", "nan", "if", "field", "!=", "'volume'", ":", "value", "*=", "self", ".", "_ohlc_ratio_inverse_for_sid", "(", "sid", ")", "return", "value" ]

[ "Retrieve", "the", "pricing", "info", "for", "the", "given", "sid", "dt", "and", "field", "." ]

[ "def", "search", "(", "self", ",", "buf", ")", ":", "self", ".", "_check_type", "(", "buf", ")", "normalized", "=", "unicodedata", ".", "normalize", "(", "self", ".", "FORM", ",", "buf", ")", "idx", "=", "normalized", ".", "find", "(", "self", ".", "_text", ")", "if", "idx", "<", "0", ":", "return", "None", "start", "=", "idx", "end", "=", "idx", "+", "len", "(", "self", ".", "_text", ")", "return", "SequenceMatch", "(", "self", ",", "normalized", "[", "start", ":", "end", "]", ",", "start", ",", "end", ")" ]

[ "Search", "the", "provided", "buffer", "for", "matching", "text", "." ]

[ "def", "sqlite3_backup", "(", "src_path", ",", "dest_path", ")", ":", "# find sqlite3", "sqlite3_path", "=", "sqlite3_find_tool", "(", ")", "if", "sqlite3_path", "is", "None", ":", "log", ".", "error", "(", "\"Failed to find sqlite3 tool\"", ")", "return", "False", "sqlite3_cmd", "=", "[", "sqlite3_path", ",", "'{}'", ".", "format", "(", "src_path", ")", ",", "'.backup \"{}\"'", ".", "format", "(", "dest_path", ")", "]", "rc", "=", "None", "backoff", "=", "1.0", "out", "=", "None", "err", "=", "None", "try", ":", "while", "True", ":", "log", ".", "debug", "(", "\"{}\"", ".", "format", "(", "\" \"", ".", "join", "(", "sqlite3_cmd", ")", ")", ")", "p", "=", "subprocess", ".", "Popen", "(", "sqlite3_cmd", ",", "shell", "=", "False", ",", "close_fds", "=", "True", ",", "stdout", "=", "subprocess", ".", "PIPE", ",", "stderr", "=", "subprocess", ".", "PIPE", ")", "out", ",", "err", "=", "p", ".", "communicate", "(", ")", "rc", "=", "p", ".", "wait", "(", ")", "if", "rc", "!=", "0", ":", "if", "\"database is locked\"", "in", "out", ".", "lower", "(", ")", "or", "\"database is locked\"", "in", "err", ".", "lower", "(", ")", ":", "# try again", "log", ".", "error", "(", "\"Database {} is locked; trying again in {} seconds\"", ".", "format", "(", "src_path", ",", "backoff", ")", ")", "time", ".", "sleep", "(", "backoff", ")", "backoff", "+=", "2", "*", "backoff", "+", "random", ".", "random", "(", ")", "*", "random", ".", "randint", "(", "0", ",", "int", "(", "backoff", ")", ")", "continue", "elif", "'is not a database'", "in", "out", ".", "lower", "(", ")", "or", "'is not a database'", "in", "err", ".", "lower", "(", ")", ":", "# not a valid sqlite3 file", "log", ".", "error", "(", "\"File {} is not a SQLite database\"", ".", "format", "(", "src_path", ")", ")", "return", "False", "else", ":", "# some other failure. Try again", "log", ".", "error", "(", "'Failed to back up with \"{}\". Error log follows.\\n{}'", ".", "format", "(", "\" \"", ".", "join", "(", "sqlite3_cmd", ")", ",", "err", ")", ")", "continue", "else", ":", "break", "except", "Exception", ",", "e", ":", "log", ".", "exception", "(", "e", ")", "return", "False", "if", "not", "os", ".", "WIFEXITED", "(", "rc", ")", ":", "# bad exit ", "# failed for some other reason", "log", ".", "error", "(", "\"Backup failed: out='{}', err='{}', rc={}\"", ".", "format", "(", "out", ",", "err", ",", "rc", ")", ")", "return", "False", "if", "os", ".", "WEXITSTATUS", "(", "rc", ")", "!=", "0", ":", "# bad exit", "log", ".", "error", "(", "\"Backup failed: out='{}', err='{}', exit={}\"", ".", "format", "(", "out", ",", "err", ",", "os", ".", "WEXITSTATUS", "(", "rc", ")", ")", ")", "return", "False", "return", "True" ]

[ "Back", "up", "a", "sqlite3", "database", "while", "ensuring", "that", "no", "ongoing", "queries", "are", "being", "executed", "." ]

[ "def", "_validate_date_like_dtype", "(", "dtype", ")", ":", "try", ":", "typ", "=", "np", ".", "datetime_data", "(", "dtype", ")", "[", "0", "]", "except", "ValueError", "as", "e", ":", "raise", "TypeError", "(", "'{error}'", ".", "format", "(", "error", "=", "e", ")", ")", "if", "typ", "!=", "'generic'", "and", "typ", "!=", "'ns'", ":", "msg", "=", "'{name!r} is too specific of a frequency, try passing {type!r}'", "raise", "ValueError", "(", "msg", ".", "format", "(", "name", "=", "dtype", ".", "name", ",", "type", "=", "dtype", ".", "type", ".", "__name__", ")", ")" ]

[ "Check", "whether", "the", "dtype", "is", "a", "date", "-", "like", "dtype", ".", "Raises", "an", "error", "if", "invalid", "." ]

[ "def", "blastn", "(", "sequences", ",", "locus", ",", "nseqs", ",", "kir", "=", "False", ",", "verbose", "=", "False", ",", "refdata", "=", "None", ",", "evalue", "=", "10", ")", ":", "logger", "=", "logging", ".", "getLogger", "(", "\"Logger.\"", "+", "__name__", ")", "if", "not", "refdata", ":", "refdata", "=", "ReferenceData", "(", ")", "file_id", "=", "str", "(", "randomid", "(", ")", ")", "input_fasta", "=", "file_id", "+", "\".fasta\"", "output_xml", "=", "file_id", "+", "\".xml\"", "SeqIO", ".", "write", "(", "sequences", ",", "input_fasta", ",", "\"fasta\"", ")", "blastn_cline", "=", "NcbiblastnCommandline", "(", "query", "=", "input_fasta", ",", "db", "=", "refdata", ".", "blastdb", ",", "evalue", "=", "evalue", ",", "outfmt", "=", "5", ",", "reward", "=", "1", ",", "penalty", "=", "-", "3", ",", "gapopen", "=", "5", ",", "gapextend", "=", "2", ",", "dust", "=", "'yes'", ",", "out", "=", "output_xml", ")", "stdout", ",", "stderr", "=", "blastn_cline", "(", ")", "loc", "=", "locus", "if", "not", "kir", ":", "loc", "=", "locus", ".", "split", "(", "\"-\"", ")", "[", "1", "]", "blast_qresult", "=", "SearchIO", ".", "read", "(", "output_xml", ",", "'blast-xml'", ")", "# Delete files", "cleanup", "(", "file_id", ")", "# TODO: Use logging", "if", "len", "(", "blast_qresult", ".", "hits", ")", "==", "0", ":", "if", "verbose", ":", "logger", ".", "error", "(", "\"Failed blast! No hits!\"", ")", "logger", ".", "error", "(", "stderr", ")", "return", "Blast", "(", "failed", "=", "True", ")", "alleles", "=", "[", "]", "full_sequences", "=", "[", "]", "load_blast", "=", "70", "if", "nseqs", "<", "70", "else", "nseqs", "l", "=", "len", "(", "blast_qresult", ".", "hits", ")", "if", "load_blast", ">", "len", "(", "blast_qresult", ".", "hits", ")", "else", "load_blast", "# TODO: update all blast files to have HLA-", "if", "locus", "in", "refdata", ".", "hla_loci", "and", "not", "kir", ":", "alleles", "=", "[", "blast_qresult", "[", "i", "]", ".", "id", ".", "split", "(", "\"_\"", ")", "[", "0", "]", "for", "i", "in", "range", "(", "0", ",", "l", ")", "if", "blast_qresult", "[", "i", "]", ".", "id", ".", "split", "(", "\"*\"", ")", "[", "0", "]", "==", "locus", "or", "\"HLA-\"", "+", "blast_qresult", "[", "i", "]", ".", "id", ".", "split", "(", "\"*\"", ")", "[", "0", "]", "==", "locus", "]", "alleles", "=", "[", "\"HLA-\"", "+", "a", "if", "not", "has_hla", "(", "a", ")", "else", "a", "for", "a", "in", "alleles", "]", "if", "kir", ":", "alleles", "=", "[", "blast_qresult", "[", "i", "]", ".", "id", ".", "split", "(", "\"_\"", ")", "[", "0", "]", "for", "i", "in", "range", "(", "0", ",", "l", ")", "if", "blast_qresult", "[", "i", "]", ".", "id", ".", "split", "(", "\"*\"", ")", "[", "0", "]", "==", "locus", "]", "if", "verbose", ":", "logger", ".", "info", "(", "\"Blast alleles: \"", "+", "\",\"", ".", "join", "(", "alleles", ")", ")", "# TODO: sort alleles by number of features they contain and evalue", "# Use biosql db if provided", "# otherwise use IMGT dat file", "final_seqs", "=", "[", "]", "rmax", "=", "refdata", ".", "structure_max", "[", "locus", "]", "if", "refdata", ".", "server_avail", ":", "db", "=", "refdata", ".", "server", "[", "refdata", ".", "dbversion", "+", "\"_\"", "+", "loc", "]", "full_sequences", "=", "[", "]", "for", "n", "in", "alleles", ":", "if", "n", "in", "refdata", ".", "hla_names", ":", "try", ":", "seq", "=", "db", ".", "lookup", "(", "name", "=", "n", ")", "full_sequences", ".", "append", "(", "seq", ")", "except", ":", "logger", ".", "error", "(", "\"Allele doesnt exist in IMGT BioSQL DB!! \"", "+", "n", ")", "else", ":", "if", "verbose", ":", "logger", ".", "info", "(", "\"Getting sequences from HLA.dat file\"", ")", "full_sequences", "=", "[", "refdata", ".", "hlaref", "[", "a", "]", "for", "a", "in", "alleles", "if", "a", "in", "refdata", ".", "hlaref", "]", "for", "s", "in", "full_sequences", ":", "s", ".", "name", "=", "s", ".", "description", ".", "split", "(", "\",\"", ")", "[", "0", "]", "i", "=", "1", "last_seq", "=", "[", "]", "max_f", "=", "0", "added_max", "=", "False", "full_feats", "=", "False", "for", "s", "in", "full_sequences", ":", "fs", "=", "len", "(", "[", "f", ".", "type", "for", "f", "in", "s", ".", "features", "if", "not", "f", ".", "type", "in", "[", "'source'", ",", "'CDS'", "]", "]", ")", "if", "i", "<=", "nseqs", ":", "final_seqs", ".", "append", "(", "s", ")", "max_f", "=", "fs", "if", "fs", ">", "max_f", "else", "max_f", "if", "i", "<=", "nseqs", "and", "max_f", "<", "rmax", ":", "full_feats", "=", "True", "if", "(", "i", ">=", "nseqs", "and", "fs", "==", "max_f", "and", "not", "added_max", ")", ":", "if", "len", "(", "last_seq", ")", ">=", "10", ":", "last_seq", ".", "insert", "(", "3", ",", "s", ")", "else", ":", "last_seq", ".", "append", "(", "s", ")", "added_max", "=", "True", "if", "(", "fs", ">", "max_f", "and", "len", "(", "last_seq", ")", "<", "10", "and", "i", ">=", "nseqs", "and", "len", "(", "last_seq", ")", "<", "10", ")", ":", "last_seq", ".", "append", "(", "s", ")", "i", "+=", "1", "if", "full_feats", ":", "for", "s", "in", "last_seq", ":", "final_seqs", ".", "append", "(", "s", ")", "# Build Blast object", "blast_o", "=", "Blast", "(", "match_seqs", "=", "final_seqs", ",", "alleles", "=", "alleles", ")", "return", "blast_o" ]

[ "Gets", "the", "a", "list", "of", "alleles", "that", "are", "the", "most", "similar", "to", "the", "input", "sequence" ]

[ "def", "get_global_state", "(", "self", ")", ":", "query_processor", "=", "self", ".", "_get_sync_query_processor", "(", "GlobalStateQuery", ".", "pack_req", ",", "GlobalStateQuery", ".", "unpack_rsp", ")", "kargs", "=", "{", "'user_id'", ":", "self", ".", "get_login_user_id", "(", ")", ",", "'conn_id'", ":", "self", ".", "get_sync_conn_id", "(", ")", ",", "}", "ret_code", ",", "msg", ",", "state_dict", "=", "query_processor", "(", "*", "*", "kargs", ")", "if", "ret_code", "!=", "RET_OK", ":", "return", "ret_code", ",", "msg", "return", "RET_OK", ",", "state_dict" ]

[ "获取全局状态" ]

[ "def", "query_metric_stats", "(", "self", ",", "metric_type", ",", "metric_id", "=", "None", ",", "start", "=", "None", ",", "end", "=", "None", ",", "bucketDuration", "=", "None", ",", "*", "*", "query_options", ")", ":", "if", "start", "is", "not", "None", ":", "if", "type", "(", "start", ")", "is", "datetime", ":", "query_options", "[", "'start'", "]", "=", "datetime_to_time_millis", "(", "start", ")", "else", ":", "query_options", "[", "'start'", "]", "=", "start", "if", "end", "is", "not", "None", ":", "if", "type", "(", "end", ")", "is", "datetime", ":", "query_options", "[", "'end'", "]", "=", "datetime_to_time_millis", "(", "end", ")", "else", ":", "query_options", "[", "'end'", "]", "=", "end", "if", "bucketDuration", "is", "not", "None", ":", "if", "type", "(", "bucketDuration", ")", "is", "timedelta", ":", "query_options", "[", "'bucketDuration'", "]", "=", "timedelta_to_duration", "(", "bucketDuration", ")", "else", ":", "query_options", "[", "'bucketDuration'", "]", "=", "bucketDuration", "if", "metric_id", "is", "not", "None", ":", "url", "=", "self", ".", "_get_metrics_stats_url", "(", "self", ".", "_get_metrics_single_url", "(", "metric_type", ",", "metric_id", ")", ")", "else", ":", "if", "len", "(", "query_options", ")", "<", "0", ":", "raise", "HawkularError", "(", "'Tags are required when querying without metric_id'", ")", "url", "=", "self", ".", "_get_metrics_stats_url", "(", "self", ".", "_get_url", "(", "metric_type", ")", ")", "return", "self", ".", "_get", "(", "url", ",", "*", "*", "query_options", ")" ]

[ "Query", "for", "metric", "aggregates", "from", "the", "server", ".", "This", "is", "called", "buckets", "in", "the", "Hawkular", "-", "Metrics", "documentation", "." ]

[ "def", "winner", "(", "self", ")", ":", "for", "potential_win", "in", "self", ".", "_potential_wins", "(", ")", ":", "if", "potential_win", "==", "tuple", "(", "'XXX'", ")", ":", "return", "Outcome", ".", "win_for_crosses", "elif", "potential_win", "==", "tuple", "(", "'OOO'", ")", ":", "return", "Outcome", ".", "win_for_naughts", "if", "self", ".", "_count", "(", "' '", ")", "==", "0", ":", "return", "Outcome", ".", "draw", "return", "Outcome", ".", "ongoing" ]

[ "The", "winner", "of", "this", "board", "if", "one", "exists", "." ]

[ "def", "keyPressEvent", "(", "self", ",", "event", ")", ":", "QToolTip", ".", "hideText", "(", ")", "ctrl", "=", "event", ".", "modifiers", "(", ")", "&", "Qt", ".", "ControlModifier", "if", "event", ".", "key", "(", ")", "in", "[", "Qt", ".", "Key_Enter", ",", "Qt", ".", "Key_Return", "]", ":", "if", "ctrl", ":", "self", ".", "process_text", "(", "array", "=", "False", ")", "else", ":", "self", ".", "process_text", "(", "array", "=", "True", ")", "self", ".", "accept", "(", ")", "else", ":", "QDialog", ".", "keyPressEvent", "(", "self", ",", "event", ")" ]

[ "Qt", "override", "." ]

[ "def", "pause", "(", "info", "=", "'Press any key to continue ...'", ",", "err", "=", "False", ")", ":", "if", "not", "isatty", "(", "sys", ".", "stdin", ")", "or", "not", "isatty", "(", "sys", ".", "stdout", ")", ":", "return", "try", ":", "if", "info", ":", "echo", "(", "info", ",", "nl", "=", "False", ",", "err", "=", "err", ")", "try", ":", "getchar", "(", ")", "except", "(", "KeyboardInterrupt", ",", "EOFError", ")", ":", "pass", "finally", ":", "if", "info", ":", "echo", "(", "err", "=", "err", ")" ]

[ "This", "command", "stops", "execution", "and", "waits", "for", "the", "user", "to", "press", "any", "key", "to", "continue", ".", "This", "is", "similar", "to", "the", "Windows", "batch", "pause", "command", ".", "If", "the", "program", "is", "not", "run", "through", "a", "terminal", "this", "command", "will", "instead", "do", "nothing", "." ]

[ "def", "initOptions", "(", "self", ",", "options", ")", ":", "self", ".", "setAutoIndent", "(", "options", ".", "value", "(", "'autoIndent'", ")", ")", "self", ".", "setIndentationsUseTabs", "(", "options", ".", "value", "(", "'indentationsUseTabs'", ")", ")", "self", ".", "setTabIndents", "(", "options", ".", "value", "(", "'tabIndents'", ")", ")", "self", ".", "setTabWidth", "(", "options", ".", "value", "(", "'tabWidth'", ")", ")", "self", ".", "setCaretLineVisible", "(", "options", ".", "value", "(", "'showCaretLine'", ")", ")", "self", ".", "setShowWhitespaces", "(", "options", ".", "value", "(", "'showWhitespaces'", ")", ")", "self", ".", "setMarginLineNumbers", "(", "0", ",", "options", ".", "value", "(", "'showLineNumbers'", ")", ")", "self", ".", "setIndentationGuides", "(", "options", ".", "value", "(", "'showIndentations'", ")", ")", "self", ".", "setEolVisibility", "(", "options", ".", "value", "(", "'showEndlines'", ")", ")", "if", "options", ".", "value", "(", "'showLimitColumn'", ")", ":", "self", ".", "setEdgeMode", "(", "self", ".", "EdgeLine", ")", "self", ".", "setEdgeColumn", "(", "options", ".", "value", "(", "'limitColumn'", ")", ")", "else", ":", "self", ".", "setEdgeMode", "(", "self", ".", "EdgeNone", ")", "if", "options", ".", "value", "(", "'showLineWrap'", ")", ":", "self", ".", "setWrapMode", "(", "self", ".", "WrapWord", ")", "else", ":", "self", ".", "setWrapMode", "(", "self", ".", "WrapNone", ")", "# set the autocompletion source", "if", "options", ".", "value", "(", "'autoComplete'", ")", ":", "self", ".", "setAutoCompletionSource", "(", "QsciScintilla", ".", "AcsAll", ")", "else", ":", "self", ".", "setAutoCompletionSource", "(", "QsciScintilla", ".", "AcsNone", ")", "self", ".", "setAutoCompletionThreshold", "(", "options", ".", "value", "(", "'autoCompleteThreshold'", ")", ")", "# update the font information\r", "font", "=", "options", ".", "value", "(", "'documentFont'", ")", "font", ".", "setPointSize", "(", "options", ".", "value", "(", "'documentFontSize'", ")", ")", "self", ".", "setFont", "(", "font", ")", "# udpate the lexer\r", "lexer", "=", "self", ".", "lexer", "(", ")", "if", "lexer", ":", "lexer", ".", "setFont", "(", "font", ")", "# create the margin font option", "mfont", "=", "options", ".", "value", "(", "'documentMarginFont'", ")", "mfont", ".", "setPointSize", "(", "font", ".", "pointSize", "(", ")", "-", "2", ")", "self", ".", "setMarginsFont", "(", "mfont", ")", "self", ".", "setMarginWidth", "(", "0", ",", "QFontMetrics", "(", "mfont", ")", ".", "width", "(", "'0000000'", ")", "+", "5", ")" ]

[ "Initializes", "the", "edit", "with", "the", "inputed", "options", "data", "set", ".", ":", "param", "options", "|", "<XScintillaEditOptions", ">" ]

[ "def", "_decode", "(", "self", ",", "data", ",", "algorithm", ",", "key", "=", "None", ")", ":", "if", "algorithm", "[", "'type'", "]", "==", "'hmac'", ":", "verify_signature", "=", "data", "[", "-", "algorithm", "[", "'hash_size'", "]", ":", "]", "data", "=", "data", "[", ":", "-", "algorithm", "[", "'hash_size'", "]", "]", "signature", "=", "self", ".", "_hmac_generate", "(", "data", ",", "algorithm", ",", "key", ")", "if", "not", "const_equal", "(", "verify_signature", ",", "signature", ")", ":", "raise", "Exception", "(", "'Invalid signature'", ")", "return", "data", "elif", "algorithm", "[", "'type'", "]", "==", "'aes'", ":", "return", "self", ".", "_aes_decrypt", "(", "data", ",", "algorithm", ",", "key", ")", "elif", "algorithm", "[", "'type'", "]", "==", "'no-serialization'", ":", "return", "data", "elif", "algorithm", "[", "'type'", "]", "==", "'json'", ":", "return", "json", ".", "loads", "(", "data", ")", "elif", "algorithm", "[", "'type'", "]", "==", "'no-compression'", ":", "return", "data", "elif", "algorithm", "[", "'type'", "]", "==", "'gzip'", ":", "return", "self", ".", "_zlib_decompress", "(", "data", ",", "algorithm", ")", "else", ":", "raise", "Exception", "(", "'Algorithm not supported: %s'", "%", "algorithm", "[", "'type'", "]", ")" ]

[ "Decode", "data", "with", "specific", "algorithm" ]

[ "def", "_process_callback", "(", "self", ",", "statefield", ")", ":", "# retrieve session and callback variables", "try", ":", "session_csrf_token", "=", "session", ".", "get", "(", "'oidc_csrf_token'", ")", "state", "=", "_json_loads", "(", "urlsafe_b64decode", "(", "request", ".", "args", "[", "'state'", "]", ".", "encode", "(", "'utf-8'", ")", ")", ")", "csrf_token", "=", "state", "[", "'csrf_token'", "]", "code", "=", "request", ".", "args", "[", "'code'", "]", "except", "(", "KeyError", ",", "ValueError", ")", ":", "logger", ".", "debug", "(", "\"Can't retrieve CSRF token, state, or code\"", ",", "exc_info", "=", "True", ")", "return", "True", ",", "self", ".", "_oidc_error", "(", ")", "# check callback CSRF token passed to IdP", "# against session CSRF token held by user", "if", "csrf_token", "!=", "session_csrf_token", ":", "logger", ".", "debug", "(", "\"CSRF token mismatch\"", ")", "return", "True", ",", "self", ".", "_oidc_error", "(", ")", "# make a request to IdP to exchange the auth code for OAuth credentials", "flow", "=", "self", ".", "_flow_for_request", "(", ")", "credentials", "=", "flow", ".", "step2_exchange", "(", "code", ")", "id_token", "=", "credentials", ".", "id_token", "if", "not", "self", ".", "_is_id_token_valid", "(", "id_token", ")", ":", "logger", ".", "debug", "(", "\"Invalid ID token\"", ")", "if", "id_token", ".", "get", "(", "'hd'", ")", "!=", "current_app", ".", "config", "[", "'OIDC_GOOGLE_APPS_DOMAIN'", "]", ":", "return", "True", ",", "self", ".", "_oidc_error", "(", "\"You must log in with an account from the {0} domain.\"", ".", "format", "(", "current_app", ".", "config", "[", "'OIDC_GOOGLE_APPS_DOMAIN'", "]", ")", ",", "self", ".", "WRONG_GOOGLE_APPS_DOMAIN", ")", "return", "True", ",", "self", ".", "_oidc_error", "(", ")", "# store credentials by subject", "# when Google is the IdP, the subject is their G+ account number", "self", ".", "credentials_store", "[", "id_token", "[", "'sub'", "]", "]", "=", "credentials", ".", "to_json", "(", ")", "# Retrieve the extra statefield data", "try", ":", "response", "=", "self", ".", "extra_data_serializer", ".", "loads", "(", "state", "[", "statefield", "]", ")", "except", "BadSignature", ":", "logger", ".", "error", "(", "'State field was invalid'", ")", "return", "True", ",", "self", ".", "_oidc_error", "(", ")", "# set a persistent signed cookie containing the ID token", "# and redirect to the final destination", "self", ".", "_set_cookie_id_token", "(", "id_token", ")", "return", "False", ",", "response" ]

[ "Exchange", "the", "auth", "code", "for", "actual", "credentials", "then", "redirect", "to", "the", "originally", "requested", "page", "." ]

[ "def", "index_to_slices", "(", "index", ")", ":", "if", "len", "(", "index", ")", "==", "0", ":", "return", "[", "]", "#contruct the return structure", "ind", "=", "np", ".", "asarray", "(", "index", ",", "dtype", "=", "np", ".", "int", ")", "ret", "=", "[", "[", "]", "for", "i", "in", "range", "(", "ind", ".", "max", "(", ")", "+", "1", ")", "]", "#find the switchpoints", "ind_", "=", "np", ".", "hstack", "(", "(", "ind", ",", "ind", "[", "0", "]", "+", "ind", "[", "-", "1", "]", "+", "1", ")", ")", "switchpoints", "=", "np", ".", "nonzero", "(", "ind_", "-", "np", ".", "roll", "(", "ind_", ",", "+", "1", ")", ")", "[", "0", "]", "[", "ret", "[", "ind_i", "]", ".", "append", "(", "slice", "(", "*", "indexes_i", ")", ")", "for", "ind_i", ",", "indexes_i", "in", "zip", "(", "ind", "[", "switchpoints", "[", ":", "-", "1", "]", "]", ",", "zip", "(", "switchpoints", ",", "switchpoints", "[", "1", ":", "]", ")", ")", "]", "return", "ret" ]

[ "take", "a", "numpy", "array", "of", "integers", "(", "index", ")", "and", "return", "a", "nested", "list", "of", "slices", "such", "that", "the", "slices", "describe", "the", "start", "stop", "points", "for", "each", "integer", "in", "the", "index", "." ]

[ "def", "fetch_open_data", "(", "cls", ",", "ifo", ",", "start", ",", "end", ",", "sample_rate", "=", "4096", ",", "tag", "=", "None", ",", "version", "=", "None", ",", "format", "=", "'hdf5'", ",", "host", "=", "GWOSC_DEFAULT_HOST", ",", "verbose", "=", "False", ",", "cache", "=", "None", ",", "*", "*", "kwargs", ")", ":", "from", ".", "io", ".", "losc", "import", "fetch_losc_data", "return", "fetch_losc_data", "(", "ifo", ",", "start", ",", "end", ",", "sample_rate", "=", "sample_rate", ",", "tag", "=", "tag", ",", "version", "=", "version", ",", "format", "=", "format", ",", "verbose", "=", "verbose", ",", "cache", "=", "cache", ",", "host", "=", "host", ",", "cls", "=", "cls", ",", "*", "*", "kwargs", ")" ]

[ "Fetch", "open", "-", "access", "data", "from", "the", "LIGO", "Open", "Science", "Center" ]

[ "def", "_workdir", "(", "self", ",", "line", ")", ":", "workdir", "=", "self", ".", "_setup", "(", "'WORKDIR'", ",", "line", ")", "line", "=", "\"cd %s\"", "%", "(", "''", ".", "join", "(", "workdir", ")", ")", "self", ".", "install", ".", "append", "(", "line", ")" ]

[ "A", "Docker", "WORKDIR", "command", "simply", "implies", "to", "cd", "to", "that", "location" ]

[ "def", "process_frames_mouth", "(", "self", ",", "frames", ")", ":", "self", ".", "face", "=", "np", ".", "array", "(", "frames", ")", "self", ".", "mouth", "=", "np", ".", "array", "(", "frames", ")", "self", ".", "set_data", "(", "frames", ")" ]

[ "Preprocess", "from", "frames", "using", "mouth", "detector" ]

[ "def", "findall", "(", "self", ",", "obj", ",", "forced_type", "=", "None", ",", "cls", "=", "anyconfig", ".", "models", ".", "processor", ".", "Processor", ")", ":", "return", "[", "p", "(", ")", "for", "p", "in", "findall", "(", "obj", ",", "self", ".", "list", "(", ")", ",", "forced_type", "=", "forced_type", ",", "cls", "=", "cls", ")", "]" ]

[ ":", "param", "obj", ":", "a", "file", "path", "file", "file", "-", "like", "object", "pathlib", ".", "Path", "object", "or", "an", "anyconfig", ".", "globals", ".", "IOInfo", "(", "namedtuple", ")", "object", ":", "param", "forced_type", ":", "Forced", "processor", "type", "to", "find", ":", "param", "cls", ":", "A", "class", "object", "to", "compare", "with", "ptype" ]

[ "def", "_get_chrbands", "(", "self", ",", "limit", ",", "taxon", ")", ":", "if", "limit", "is", "None", ":", "limit", "=", "sys", ".", "maxsize", "# practical limit anyway", "model", "=", "Model", "(", "self", ".", "graph", ")", "line_counter", "=", "0", "myfile", "=", "'/'", ".", "join", "(", "(", "self", ".", "rawdir", ",", "self", ".", "files", "[", "taxon", "]", "[", "'file'", "]", ")", ")", "LOG", ".", "info", "(", "\"Processing Chr bands from FILE: %s\"", ",", "myfile", ")", "geno", "=", "Genotype", "(", "self", ".", "graph", ")", "monochrom", "=", "Monochrom", "(", "self", ".", "graph_type", ",", "self", ".", "are_bnodes_skized", ")", "# used to hold band definitions for a chr", "# in order to compute extent of encompasing bands", "mybands", "=", "{", "}", "# build the organism's genome from the taxon", "genome_label", "=", "self", ".", "files", "[", "taxon", "]", "[", "'genome_label'", "]", "taxon_id", "=", "'NCBITaxon:'", "+", "taxon", "# add the taxon as a class. adding the class label elsewhere", "model", ".", "addClassToGraph", "(", "taxon_id", ",", "None", ")", "model", ".", "addSynonym", "(", "taxon_id", ",", "genome_label", ")", "geno", ".", "addGenome", "(", "taxon_id", ",", "genome_label", ")", "# add the build and the taxon it's in", "build_num", "=", "self", ".", "files", "[", "taxon", "]", "[", "'build_num'", "]", "build_id", "=", "'UCSC:'", "+", "build_num", "geno", ".", "addReferenceGenome", "(", "build_id", ",", "build_num", ",", "taxon_id", ")", "# process the bands", "col", "=", "[", "'scaffold'", ",", "'start'", ",", "'stop'", ",", "'band_num'", ",", "'rtype'", "]", "with", "gzip", ".", "open", "(", "myfile", ",", "'rb'", ")", "as", "f", ":", "for", "line", "in", "f", ":", "line_counter", "+=", "1", "# skip comments", "line", "=", "line", ".", "decode", "(", ")", ".", "strip", "(", ")", "if", "line", "[", "0", "]", "==", "'#'", "or", "line_counter", ">", "limit", ":", "continue", "# chr13\t4500000\t10000000\tp12\tstalk", "row", "=", "line", ".", "split", "(", "'\\t'", ")", "scaffold", "=", "row", "[", "col", ".", "index", "(", "'scaffold'", ")", "]", "start", "=", "row", "[", "col", ".", "index", "(", "'start'", ")", "]", "stop", "=", "row", "[", "col", ".", "index", "(", "'stop'", ")", "]", "band_num", "=", "row", "[", "col", ".", "index", "(", "'band_num'", ")", "]", ".", "strip", "(", ")", "rtype", "=", "row", "[", "col", ".", "index", "(", "'rtype'", ")", "]", "# NOTE some less-finished genomes have", "# placed and unplaced scaffolds", "# * Placed scaffolds:", "# the scaffolds have been placed within a chromosome.", "# * Unlocalized scaffolds:", "# although the chromosome within which the scaffold occurs", "# is known, the scaffold's position or orientation", "# is not known.", "# * Unplaced scaffolds:", "# it is not known which chromosome the scaffold belongs to", "#", "# find out if the thing is a full on chromosome, or a scaffold:", "# ex: unlocalized scaffold: chr10_KL568008v1_random", "# ex: unplaced scaffold: chrUn_AABR07022428v1", "placed_scaffold_pattern", "=", "r'(chr(?:\\d+|X|Y|Z|W|M))'", "unlocalized_scaffold_pattern", "=", "placed_scaffold_pattern", "+", "r'_(\\w+)_random'", "unplaced_scaffold_pattern", "=", "r'chr(Un(?:_\\w+)?)'", "mch", "=", "re", ".", "match", "(", "placed_scaffold_pattern", "+", "r'$'", ",", "scaffold", ")", "if", "mch", "is", "not", "None", "and", "len", "(", "mch", ".", "groups", "(", ")", ")", "==", "1", ":", "# the chromosome is the first match of the pattern", "chrom_num", "=", "mch", ".", "group", "(", "1", ")", "else", ":", "# skip over anything that isn't a placed_scaffold", "# at the class level", "LOG", ".", "info", "(", "\"Found non-placed chromosome %s\"", ",", "scaffold", ")", "chrom_num", "=", "None", "m_chr_unloc", "=", "re", ".", "match", "(", "unlocalized_scaffold_pattern", ",", "scaffold", ")", "m_chr_unplaced", "=", "re", ".", "match", "(", "unplaced_scaffold_pattern", ",", "scaffold", ")", "scaffold_num", "=", "None", "if", "mch", ":", "pass", "elif", "m_chr_unloc", "is", "not", "None", "and", "len", "(", "m_chr_unloc", ".", "groups", "(", ")", ")", "==", "2", ":", "chrom_num", "=", "m_chr_unloc", ".", "group", "(", "1", ")", "scaffold_num", "=", "chrom_num", "+", "'_'", "+", "m_chr_unloc", ".", "group", "(", "2", ")", "elif", "m_chr_unplaced", "is", "not", "None", "and", "len", "(", "m_chr_unplaced", ".", "groups", "(", ")", ")", "==", "1", ":", "scaffold_num", "=", "m_chr_unplaced", ".", "group", "(", "1", ")", "else", ":", "LOG", ".", "error", "(", "\"There's a chr pattern that we aren't matching: %s\"", ",", "scaffold", ")", "if", "chrom_num", "is", "not", "None", ":", "# the chrom class (generic) id", "chrom_class_id", "=", "makeChromID", "(", "chrom_num", ",", "taxon", ",", "'CHR'", ")", "# first, add the chromosome class (in the taxon)", "geno", ".", "addChromosomeClass", "(", "chrom_num", ",", "taxon_id", ",", "self", ".", "files", "[", "taxon", "]", "[", "'genome_label'", "]", ")", "# then, add the chromosome instance (from the given build)", "geno", ".", "addChromosomeInstance", "(", "chrom_num", ",", "build_id", ",", "build_num", ",", "chrom_class_id", ")", "# add the chr to the hashmap of coordinates for this build", "# the chromosome coordinate space is itself", "if", "chrom_num", "not", "in", "mybands", ".", "keys", "(", ")", ":", "mybands", "[", "chrom_num", "]", "=", "{", "'min'", ":", "0", ",", "'max'", ":", "int", "(", "stop", ")", ",", "'chr'", ":", "chrom_num", ",", "'ref'", ":", "build_id", ",", "'parent'", ":", "None", ",", "'stain'", ":", "None", ",", "'type'", ":", "self", ".", "globaltt", "[", "'chromosome'", "]", "}", "if", "scaffold_num", "is", "not", "None", ":", "# this will put the coordinates of the scaffold", "# in the scaffold-space and make sure that the scaffold", "# is part of the correct parent.", "# if chrom_num is None,", "# then it will attach it to the genome,", "# just like a reg chrom", "mybands", "[", "scaffold_num", "]", "=", "{", "'min'", ":", "start", ",", "'max'", ":", "stop", ",", "'chr'", ":", "scaffold_num", ",", "'ref'", ":", "build_id", ",", "'parent'", ":", "chrom_num", ",", "'stain'", ":", "None", ",", "'type'", ":", "self", ".", "globaltt", "[", "'assembly_component'", "]", ",", "'synonym'", ":", "scaffold", "}", "parents", "=", "list", "(", ")", "if", "band_num", "is", "not", "None", "and", "band_num", "!=", "''", ":", "# add the specific band", "mybands", "[", "chrom_num", "+", "band_num", "]", "=", "{", "'min'", ":", "start", ",", "'max'", ":", "stop", ",", "'chr'", ":", "chrom_num", ",", "'ref'", ":", "build_id", ",", "'parent'", ":", "None", ",", "'stain'", ":", "None", ",", "'type'", ":", "None", "}", "# add the staining intensity of the band", "if", "re", ".", "match", "(", "r'g(neg|pos|var)'", ",", "rtype", ")", ":", "mybands", "[", "chrom_num", "+", "band_num", "]", "[", "'stain'", "]", "=", "self", ".", "resolve", "(", "rtype", ")", "# get the parent bands, and make them unique", "parents", "=", "list", "(", "monochrom", ".", "make_parent_bands", "(", "band_num", ",", "set", "(", ")", ")", ")", "# alphabetical sort will put them in smallest to biggest,", "# so we reverse", "parents", ".", "sort", "(", "reverse", "=", "True", ")", "# print('parents of',chrom,band,':',parents)", "if", "len", "(", "parents", ")", ">", "0", ":", "mybands", "[", "chrom_num", "+", "band_num", "]", "[", "'parent'", "]", "=", "chrom_num", "+", "parents", "[", "0", "]", "# loop through the parents and add them to the hash", "# add the parents to the graph, in hierarchical order", "# TODO PYLINT Consider using enumerate", "# instead of iterating with range and len", "for", "i", "in", "range", "(", "len", "(", "parents", ")", ")", ":", "rti", "=", "getChrPartTypeByNotation", "(", "parents", "[", "i", "]", ")", "pnum", "=", "chrom_num", "+", "parents", "[", "i", "]", "sta", "=", "int", "(", "start", ")", "sto", "=", "int", "(", "stop", ")", "if", "pnum", "not", "in", "mybands", ".", "keys", "(", ")", ":", "# add the parental band to the hash", "bnd", "=", "{", "'min'", ":", "min", "(", "sta", ",", "sto", ")", ",", "'max'", ":", "max", "(", "sta", ",", "sto", ")", ",", "'chr'", ":", "chrom_num", ",", "'ref'", ":", "build_id", ",", "'parent'", ":", "None", ",", "'stain'", ":", "None", ",", "'type'", ":", "rti", "}", "mybands", "[", "pnum", "]", "=", "bnd", "else", ":", "# band already in the hash means it's a grouping band", "# need to update the min/max coords", "bnd", "=", "mybands", ".", "get", "(", "pnum", ")", "bnd", "[", "'min'", "]", "=", "min", "(", "sta", ",", "sto", ",", "bnd", "[", "'min'", "]", ")", "bnd", "[", "'max'", "]", "=", "max", "(", "sta", ",", "sto", ",", "bnd", "[", "'max'", "]", ")", "mybands", "[", "pnum", "]", "=", "bnd", "# also, set the max for the chrom", "chrom", "=", "mybands", ".", "get", "(", "chrom_num", ")", "chrom", "[", "'max'", "]", "=", "max", "(", "sta", ",", "sto", ",", "chrom", "[", "'max'", "]", ")", "mybands", "[", "chrom_num", "]", "=", "chrom", "# add the parent relationships to each", "if", "i", "<", "len", "(", "parents", ")", "-", "1", ":", "mybands", "[", "pnum", "]", "[", "'parent'", "]", "=", "chrom_num", "+", "parents", "[", "i", "+", "1", "]", "else", ":", "# add the last one (p or q usually)", "# as attached to the chromosome", "mybands", "[", "pnum", "]", "[", "'parent'", "]", "=", "chrom_num", "f", ".", "close", "(", ")", "# end looping through file", "# loop through the hash and add the bands to the graph", "for", "bnd", "in", "mybands", ".", "keys", "(", ")", ":", "myband", "=", "mybands", ".", "get", "(", "bnd", ")", "band_class_id", "=", "makeChromID", "(", "bnd", ",", "taxon", ",", "'CHR'", ")", "band_class_label", "=", "makeChromLabel", "(", "bnd", ",", "genome_label", ")", "band_build_id", "=", "makeChromID", "(", "bnd", ",", "build_num", ",", "'MONARCH'", ")", "band_build_label", "=", "makeChromLabel", "(", "bnd", ",", "build_num", ")", "# the build-specific chrom", "chrom_in_build_id", "=", "makeChromID", "(", "myband", "[", "'chr'", "]", ",", "build_num", ",", "'MONARCH'", ")", "# if it's != part, then add the class", "if", "myband", "[", "'type'", "]", "!=", "self", ".", "globaltt", "[", "'assembly_component'", "]", ":", "model", ".", "addClassToGraph", "(", "band_class_id", ",", "band_class_label", ",", "myband", "[", "'type'", "]", ")", "bfeature", "=", "Feature", "(", "self", ".", "graph", ",", "band_build_id", ",", "band_build_label", ",", "band_class_id", ")", "else", ":", "bfeature", "=", "Feature", "(", "self", ".", "graph", ",", "band_build_id", ",", "band_build_label", ",", "myband", "[", "'type'", "]", ")", "if", "'synonym'", "in", "myband", ":", "model", ".", "addSynonym", "(", "band_build_id", ",", "myband", "[", "'synonym'", "]", ")", "if", "myband", "[", "'parent'", "]", "is", "None", ":", "if", "myband", "[", "'type'", "]", "==", "self", ".", "globaltt", "[", "'assembly_component'", "]", ":", "# since we likely don't know the chr,", "# add it as a part of the build", "geno", ".", "addParts", "(", "band_build_id", ",", "build_id", ")", "elif", "myband", "[", "'type'", "]", "==", "self", ".", "globaltt", "[", "'assembly_component'", "]", ":", "# geno.addParts(band_build_id, chrom_in_build_id)", "parent_chrom_in_build", "=", "makeChromID", "(", "myband", "[", "'parent'", "]", ",", "build_num", ",", "'MONARCH'", ")", "bfeature", ".", "addSubsequenceOfFeature", "(", "parent_chrom_in_build", ")", "# add the band as a feature", "# (which also instantiates the owl:Individual)", "bfeature", ".", "addFeatureStartLocation", "(", "myband", "[", "'min'", "]", ",", "chrom_in_build_id", ")", "bfeature", ".", "addFeatureEndLocation", "(", "myband", "[", "'max'", "]", ",", "chrom_in_build_id", ")", "if", "'stain'", "in", "myband", "and", "myband", "[", "'stain'", "]", "is", "not", "None", ":", "bfeature", ".", "addFeatureProperty", "(", "self", ".", "globaltt", "[", "'has_sequence_attribute'", "]", ",", "myband", "[", "'stain'", "]", ")", "# type the band as a faldo:Region directly (add_region=False)", "# bfeature.setNoBNodes(self.nobnodes)", "# to come when we merge in ZFIN.py", "bfeature", ".", "addFeatureToGraph", "(", "False", ")", "return" ]

[ ":", "param", "limit", ":", ":", "return", ":" ]

[ "def", "xpath_page", "(", "request", ",", "uuid", ",", "version", ")", ":", "xpath_string", "=", "request", ".", "params", ".", "get", "(", "'q'", ")", "return", "execute_xpath", "(", "xpath_string", ",", "'xpath-module'", ",", "uuid", ",", "version", ")" ]

[ "Given", "a", "page", "UUID", "(", "and", "optional", "version", ")", "returns", "a", "JSON", "object", "of", "results", "as", "in", "xpath_book", "()" ]

[ "def", "purge_old_event_logs", "(", "delete_before_days", "=", "7", ")", ":", "delete_before_date", "=", "timezone", ".", "now", "(", ")", "-", "timedelta", "(", "days", "=", "delete_before_days", ")", "logs_deleted", "=", "EventLog", ".", "objects", ".", "filter", "(", "created_on__lte", "=", "delete_before_date", ")", ".", "delete", "(", ")", "return", "logs_deleted" ]

[ "Purges", "old", "event", "logs", "from", "the", "database", "table" ]

[ "def", "close", "(", "self", ")", ":", "self", ".", "daf", ".", "file", ".", "close", "(", ")", "for", "segment", "in", "self", ".", "segments", ":", "if", "hasattr", "(", "segment", ",", "'_data'", ")", ":", "del", "segment", ".", "_data", "self", ".", "daf", ".", "_array", "=", "None", "self", ".", "daf", ".", "_map", "=", "None" ]

[ "Close", "this", "SPK", "file", "." ]

[ "def", "_connect", "(", "self", ")", ":", "try", ":", "while", "True", ":", "_LOGGER", ".", "info", "(", "'Trying to connect to %s'", ",", "self", ".", "port", ")", "try", ":", "yield", "from", "serial_asyncio", ".", "create_serial_connection", "(", "self", ".", "loop", ",", "lambda", ":", "self", ".", "protocol", ",", "self", ".", "port", ",", "self", ".", "baud", ")", "return", "except", "serial", ".", "SerialException", ":", "_LOGGER", ".", "error", "(", "'Unable to connect to %s'", ",", "self", ".", "port", ")", "_LOGGER", ".", "info", "(", "'Waiting %s secs before trying to connect again'", ",", "self", ".", "reconnect_timeout", ")", "yield", "from", "asyncio", ".", "sleep", "(", "self", ".", "reconnect_timeout", ",", "loop", "=", "self", ".", "loop", ")", "except", "asyncio", ".", "CancelledError", ":", "_LOGGER", ".", "debug", "(", "'Connect attempt to %s cancelled'", ",", "self", ".", "port", ")" ]

[ "Connect", "to", "the", "serial", "port", "." ]

[ "def", "_add_references", "(", "self", ",", "rec", ")", ":", "for", "ref", "in", "self", ".", "document", ".", "getElementsByTagName", "(", "'ref'", ")", ":", "for", "ref_type", ",", "doi", ",", "authors", ",", "collaboration", ",", "journal", ",", "volume", ",", "page", ",", "year", ",", "label", ",", "arxiv", ",", "publisher", ",", "institution", ",", "unstructured_text", ",", "external_link", ",", "report_no", ",", "editors", "in", "self", ".", "_get_reference", "(", "ref", ")", ":", "subfields", "=", "[", "]", "if", "doi", ":", "subfields", ".", "append", "(", "(", "'a'", ",", "doi", ")", ")", "for", "author", "in", "authors", ":", "subfields", ".", "append", "(", "(", "'h'", ",", "author", ")", ")", "for", "editor", "in", "editors", ":", "subfields", ".", "append", "(", "(", "'e'", ",", "editor", ")", ")", "if", "year", ":", "subfields", ".", "append", "(", "(", "'y'", ",", "year", ")", ")", "if", "unstructured_text", ":", "if", "page", ":", "subfields", ".", "append", "(", "(", "'m'", ",", "unstructured_text", "+", "', '", "+", "page", ")", ")", "else", ":", "subfields", ".", "append", "(", "(", "'m'", ",", "unstructured_text", ")", ")", "if", "collaboration", ":", "subfields", ".", "append", "(", "(", "'c'", ",", "collaboration", ")", ")", "if", "institution", ":", "subfields", ".", "append", "(", "(", "'m'", ",", "institution", ")", ")", "if", "publisher", ":", "subfields", ".", "append", "(", "(", "'p'", ",", "publisher", ")", ")", "if", "arxiv", ":", "subfields", ".", "append", "(", "(", "'r'", ",", "arxiv", ")", ")", "if", "report_no", ":", "subfields", ".", "append", "(", "(", "'r'", ",", "report_no", ")", ")", "if", "external_link", ":", "subfields", ".", "append", "(", "(", "'u'", ",", "external_link", ")", ")", "if", "label", ":", "subfields", ".", "append", "(", "(", "'o'", ",", "label", ")", ")", "if", "ref_type", "==", "'book'", ":", "if", "journal", ":", "subfields", ".", "append", "(", "(", "'t'", ",", "journal", ")", ")", "if", "volume", ":", "subfields", ".", "append", "(", "(", "'m'", ",", "volume", ")", ")", "elif", "page", "and", "not", "unstructured_text", ":", "subfields", ".", "append", "(", "(", "'m'", ",", "page", ")", ")", "else", ":", "if", "volume", "and", "page", ":", "subfields", ".", "append", "(", "(", "'s'", ",", "journal", "+", "\",\"", "+", "volume", "+", "\",\"", "+", "page", ")", ")", "elif", "journal", ":", "subfields", ".", "append", "(", "(", "'t'", ",", "journal", ")", ")", "if", "ref_type", ":", "subfields", ".", "append", "(", "(", "'d'", ",", "ref_type", ")", ")", "if", "not", "subfields", ":", "#misc-type references", "try", ":", "r", "=", "ref", ".", "getElementsByTagName", "(", "'mixed-citation'", ")", "[", "0", "]", "text", "=", "xml_to_text", "(", "r", ")", "label", "=", "text", ".", "split", "(", ")", "[", "0", "]", "text", "=", "\" \"", ".", "join", "(", "text", ".", "split", "(", ")", "[", "1", ":", "]", ")", "subfields", ".", "append", "(", "(", "'s'", ",", "text", ")", ")", "record_add_field", "(", "rec", ",", "'999'", ",", "ind1", "=", "'C'", ",", "ind2", "=", "'5'", ",", "subfields", "=", "subfields", ")", "except", "IndexError", ":", "#references without 'mixed-citation' tag", "try", ":", "r", "=", "ref", ".", "getElementsByTagName", "(", "'note'", ")", "[", "0", "]", "subfields", ".", "append", "(", "(", "'s'", ",", "xml_to_text", "(", "r", ")", ")", ")", "record_add_field", "(", "rec", ",", "'999'", ",", "ind1", "=", "'C'", ",", "ind2", "=", "'5'", ",", "subfields", "=", "subfields", ")", "except", "IndexError", ":", "#references without 'note' tag", "subfields", ".", "append", "(", "(", "'s'", ",", "xml_to_text", "(", "ref", ")", ")", ")", "record_add_field", "(", "rec", ",", "'999'", ",", "ind1", "=", "'C'", ",", "ind2", "=", "'5'", ",", "subfields", "=", "subfields", ")", "else", ":", "record_add_field", "(", "rec", ",", "'999'", ",", "ind1", "=", "'C'", ",", "ind2", "=", "'5'", ",", "subfields", "=", "subfields", ")" ]

[ "Adds", "the", "reference", "to", "the", "record" ]

[ "def", "crossings_nonzero_pos2neg", "(", "data", ")", ":", "import", "numpy", "as", "np", "if", "isinstance", "(", "data", ",", "np", ".", "ndarray", ")", ":", "pass", "elif", "isinstance", "(", "data", ",", "list", ")", ":", "data", "=", "np", ".", "asarray", "(", "data", ")", "else", ":", "raise", "IOError", "(", "'data should be a numpy array'", ")", "pos", "=", "data", ">", "0", "crossings", "=", "(", "pos", "[", ":", "-", "1", "]", "&", "~", "pos", "[", "1", ":", "]", ")", ".", "nonzero", "(", ")", "[", "0", "]", "return", "crossings" ]

[ "Find", "indices", "of", "zero", "crossings", "from", "positive", "to", "negative", "values", "<http", ":", "//", "stackoverflow", ".", "com", "/", "questions", "/", "3843017", "/", "efficiently", "-", "detect", "-", "sign", "-", "changes", "-", "in", "-", "python", ">", "_", "." ]

[ "def", "format_file_node", "(", "import_graph", ",", "node", ",", "indent", ")", ":", "f", "=", "import_graph", ".", "provenance", "[", "node", "]", "if", "isinstance", "(", "f", ",", "resolve", ".", "Direct", ")", ":", "out", "=", "'+ '", "+", "f", ".", "short_path", "elif", "isinstance", "(", "f", ",", "resolve", ".", "Local", ")", ":", "out", "=", "' '", "+", "f", ".", "short_path", "elif", "isinstance", "(", "f", ",", "resolve", ".", "System", ")", ":", "out", "=", "':: '", "+", "f", ".", "short_path", "elif", "isinstance", "(", "f", ",", "resolve", ".", "Builtin", ")", ":", "out", "=", "'(%s)'", "%", "f", ".", "module_name", "else", ":", "out", "=", "'%r'", "%", "node", "return", "' '", "*", "indent", "+", "out" ]

[ "Prettyprint", "nodes", "based", "on", "their", "provenance", "." ]

[ "def", "find_cumulative_indices", "(", "list_of_numbers", ",", "search_sum", ")", ":", "u", "=", "0", "y", "=", "0", "result", "=", "[", "]", "for", "idx", ",", "val", "in", "enumerate", "(", "list_of_numbers", ")", ":", "y", "+=", "list_of_numbers", "[", "idx", "]", "while", "y", ">=", "search_sum", ":", "if", "y", "==", "search_sum", ":", "result", ".", "append", "(", "range", "(", "u", ",", "idx", "+", "1", ")", ")", "y", "-=", "list_of_numbers", "[", "u", "]", "u", "+=", "1", "# if matches are not found, empty string is returned", "# for easier cell data handling on pandas dataframe", "return", "result", "or", "''" ]

[ "find_cumulative_indices", "(", "[", "70", "58", "81", "909", "70", "215", "70", "1022", "580", "930", "898", "]", "285", ")", "-", ">", "[[", "4", "5", "]", "[", "5", "6", "]]" ]

[ "def", "build_y", "(", "self", ")", ":", "if", "not", "self", ".", "n", ":", "return", "self", ".", "y1", "=", "mul", "(", "self", ".", "u", ",", "self", ".", "g1", "+", "self", ".", "b1", "*", "1j", ")", "self", ".", "y2", "=", "mul", "(", "self", ".", "u", ",", "self", ".", "g2", "+", "self", ".", "b2", "*", "1j", ")", "self", ".", "y12", "=", "div", "(", "self", ".", "u", ",", "self", ".", "r", "+", "self", ".", "x", "*", "1j", ")", "self", ".", "m", "=", "polar", "(", "self", ".", "tap", ",", "self", ".", "phi", "*", "deg2rad", ")", "self", ".", "m2", "=", "abs", "(", "self", ".", "m", ")", "**", "2", "self", ".", "mconj", "=", "conj", "(", "self", ".", "m", ")", "# build self and mutual admittances into Y", "self", ".", "Y", "=", "spmatrix", "(", "div", "(", "self", ".", "y12", "+", "self", ".", "y1", ",", "self", ".", "m2", ")", ",", "self", ".", "a1", ",", "self", ".", "a1", ",", "(", "self", ".", "nb", ",", "self", ".", "nb", ")", ",", "'z'", ")", "self", ".", "Y", "-=", "spmatrix", "(", "div", "(", "self", ".", "y12", ",", "self", ".", "mconj", ")", ",", "self", ".", "a1", ",", "self", ".", "a2", ",", "(", "self", ".", "nb", ",", "self", ".", "nb", ")", ",", "'z'", ")", "self", ".", "Y", "-=", "spmatrix", "(", "div", "(", "self", ".", "y12", ",", "self", ".", "m", ")", ",", "self", ".", "a2", ",", "self", ".", "a1", ",", "(", "self", ".", "nb", ",", "self", ".", "nb", ")", ",", "'z'", ")", "self", ".", "Y", "+=", "spmatrix", "(", "self", ".", "y12", "+", "self", ".", "y2", ",", "self", ".", "a2", ",", "self", ".", "a2", ",", "(", "self", ".", "nb", ",", "self", ".", "nb", ")", ",", "'z'", ")" ]

[ "Build", "transmission", "line", "admittance", "matrix", "into", "self", ".", "Y" ]

[ "def", "_getInterfaces", "(", "self", ")", ":", "interfaces", "=", "{", "}", "interfacesPath", "=", "os", ".", "path", ".", "join", "(", "\"application\"", ",", "\"interface\"", ")", "interfaceList", "=", "os", ".", "listdir", "(", "interfacesPath", ")", "for", "file", "in", "interfaceList", ":", "interfaceDirectoryPath", "=", "os", ".", "path", ".", "join", "(", "interfacesPath", ",", "file", ")", "if", "not", "os", ".", "path", ".", "isdir", "(", "interfaceDirectoryPath", ")", "or", "file", ".", "startswith", "(", "\"__\"", ")", "or", "file", ".", "startswith", "(", "\".\"", ")", ":", "continue", "interfaceName", "=", "ntpath", ".", "basename", "(", "interfaceDirectoryPath", ")", "interfacePath", "=", "os", ".", "path", ".", "join", "(", "interfaceDirectoryPath", ",", "interfaceName", ")", "+", "\".py\"", "if", "not", "os", ".", "path", ".", "isfile", "(", "interfacePath", ")", ":", "continue", "# importing interface", "interfaceSpec", "=", "importlib", ".", "util", ".", "spec_from_file_location", "(", "interfaceName", ",", "interfacePath", ")", "interface", "=", "importlib", ".", "util", ".", "module_from_spec", "(", "interfaceSpec", ")", "interfaceSpec", ".", "loader", ".", "exec_module", "(", "interface", ")", "# checking if there is an interface in the file", "if", "hasattr", "(", "interface", ",", "\"Service\"", ")", ":", "# initializing interface", "interfaceInstance", "=", "interface", ".", "Service", "(", "self", ")", "interfaces", "[", "interfaceName", "]", "=", "interfaceInstance", "return", "interfaces" ]

[ "Load", "application", "communication", "interfaces", "." ]

[ "def", "run", "(", "self", ")", ":", "try", ":", "answer", "=", "urlopen", "(", "self", ".", "url", "+", "\"&mode=queue\"", ")", ".", "read", "(", ")", ".", "decode", "(", ")", "except", "(", "HTTPError", ",", "URLError", ")", "as", "error", ":", "self", ".", "output", "=", "{", "\"full_text\"", ":", "str", "(", "error", ".", "reason", ")", ",", "\"color\"", ":", "\"#FF0000\"", "}", "return", "answer", "=", "json", ".", "loads", "(", "answer", ")", "# if answer[\"status\"] exists and is False, an error occured", "if", "not", "answer", ".", "get", "(", "\"status\"", ",", "True", ")", ":", "self", ".", "output", "=", "{", "\"full_text\"", ":", "answer", "[", "\"error\"", "]", ",", "\"color\"", ":", "\"#FF0000\"", "}", "return", "queue", "=", "answer", "[", "\"queue\"", "]", "self", ".", "status", "=", "queue", "[", "\"status\"", "]", "if", "self", ".", "is_paused", "(", ")", ":", "color", "=", "self", ".", "color_paused", "elif", "self", ".", "is_downloading", "(", ")", ":", "color", "=", "self", ".", "color_downloading", "else", ":", "color", "=", "self", ".", "color", "if", "self", ".", "is_downloading", "(", ")", ":", "full_text", "=", "self", ".", "format", ".", "format", "(", "*", "*", "queue", ")", "else", ":", "full_text", "=", "self", ".", "format_paused", ".", "format", "(", "*", "*", "queue", ")", "self", ".", "output", "=", "{", "\"full_text\"", ":", "full_text", ",", "\"color\"", ":", "color", "}" ]

[ "Connect", "to", "SABnzbd", "and", "get", "the", "data", "." ]

[ "def", "send", "(", "self", ",", "message_data", ",", "delivery_mode", "=", "None", ")", ":", "self", ".", "publisher", ".", "send", "(", "message_data", ",", "delivery_mode", "=", "delivery_mode", ")" ]

[ "See", ":", "meth", ":", "Publisher", ".", "send" ]

[ "def", "_stripe_object_to_refunds", "(", "cls", ",", "target_cls", ",", "data", ",", "charge", ")", ":", "refunds", "=", "data", ".", "get", "(", "\"refunds\"", ")", "if", "not", "refunds", ":", "return", "[", "]", "refund_objs", "=", "[", "]", "for", "refund_data", "in", "refunds", ".", "get", "(", "\"data\"", ",", "[", "]", ")", ":", "item", ",", "_", "=", "target_cls", ".", "_get_or_create_from_stripe_object", "(", "refund_data", ",", "refetch", "=", "False", ")", "refund_objs", ".", "append", "(", "item", ")", "return", "refund_objs" ]

[ "Retrieves", "Refunds", "for", "a", "charge", ":", "param", "target_cls", ":", "The", "target", "class", "to", "instantiate", "per", "invoice", "item", ".", ":", "type", "target_cls", ":", "Refund", ":", "param", "data", ":", "The", "data", "dictionary", "received", "from", "the", "Stripe", "API", ".", ":", "type", "data", ":", "dict", ":", "param", "charge", ":", "The", "charge", "object", "that", "refunds", "are", "for", ".", ":", "type", "invoice", ":", "djstripe", ".", "models", ".", "Refund", ":", "return", ":" ]

[ "def", "get_char_type", "(", "ch", ")", ":", "if", "re", ".", "match", "(", "en_p", ",", "ch", ")", ":", "return", "1", "elif", "re", ".", "match", "(", "\"\\d+\"", ",", "ch", ")", ":", "return", "2", "elif", "re", ".", "match", "(", "re_han", ",", "ch", ")", ":", "return", "3", "else", ":", "return", "4" ]

[ "0", "汉字", "1", "英文字母", "2", ".", "数字", "3", ".", "其他" ]