Datasets:

---

kejian

/

codesearchnet-python-raw

like 1

[ "def", "calculate_residue_counts_perstrain", "(", "protein_pickle_path", ",", "outdir", ",", "pdbflex_keys_file", ",", "wt_pid_cutoff", "=", "None", ",", "force_rerun", "=", "False", ")", ":", "from", "collections", "import", "defaultdict", "from", "ssbio", ".", "protein", ".", "sequence", ".", "seqprop", "import", "SeqProp", "from", "ssbio", ".", "protein", ".", "sequence", ".", "properties", ".", "residues", "import", "_aa_property_dict_one", "log", "=", "logging", ".", "getLogger", "(", "__name__", ")", "protein_id", "=", "op", ".", "splitext", "(", "op", ".", "basename", "(", "protein_pickle_path", ")", ")", "[", "0", "]", ".", "split", "(", "'_'", ")", "[", "0", "]", "protein_df_outfile", "=", "op", ".", "join", "(", "outdir", ",", "'{}_protein_strain_properties.fthr'", ".", "format", "(", "protein_id", ")", ")", "if", "ssbio", ".", "utils", ".", "force_rerun", "(", "flag", "=", "force_rerun", ",", "outfile", "=", "protein_df_outfile", ")", ":", "protein", "=", "ssbio", ".", "io", ".", "load_pickle", "(", "protein_pickle_path", ")", "# First calculate disorder cuz i forgot to", "protein", ".", "get_all_disorder_predictions", "(", "representative_only", "=", "True", ")", "# Then get all subsequences", "all_protein_subseqs", "=", "protein", ".", "get_all_subsequences", "(", "pdbflex_keys_file", "=", "pdbflex_keys_file", ")", "if", "not", "all_protein_subseqs", ":", "log", ".", "error", "(", "'{}: cannot run subsequence calculator'", ".", "format", "(", "protein", ".", "id", ")", ")", "return", "# Each strain gets a dictionary", "strain_to_infodict", "=", "defaultdict", "(", "dict", ")", "for", "seqprop_to_analyze", "in", "protein", ".", "sequences", ":", "if", "seqprop_to_analyze", ".", "id", "==", "protein", ".", "representative_sequence", ".", "id", ":", "strain_id", "=", "'K12'", "elif", "type", "(", "seqprop_to_analyze", ")", "==", "SeqProp", "and", "seqprop_to_analyze", ".", "id", "!=", "protein", ".", "id", ":", "# This is to filter out other KEGGProps or UniProtProps", "strain_id", "=", "seqprop_to_analyze", ".", "id", ".", "split", "(", "'_'", ",", "1", ")", "[", "1", "]", "# This split should work for all strains", "else", ":", "continue", "## Additional filtering for genes marked as orthologous but actually have large deletions or something", "## TODO: experiment with other cutoffs?", "if", "wt_pid_cutoff", ":", "aln", "=", "protein", ".", "sequence_alignments", ".", "get_by_id", "(", "'{0}_{0}_{1}'", ".", "format", "(", "protein", ".", "id", ",", "seqprop_to_analyze", ".", "id", ")", ")", "if", "aln", ".", "annotations", "[", "'percent_identity'", "]", "<", "wt_pid_cutoff", ":", "continue", "###### Calculate \"all\" properties ######", "seqprop_to_analyze", ".", "get_biopython_pepstats", "(", ")", "# [ALL] aa_count", "if", "'amino_acids_percent-biop'", "not", "in", "seqprop_to_analyze", ".", "annotations", ":", "# May not run if weird amino acids in the sequence", "log", ".", "warning", "(", "'Protein {}, sequence {}: skipping, unable to run Biopython ProteinAnalysis'", ".", "format", "(", "protein", ".", "id", ",", "seqprop_to_analyze", ".", "id", ")", ")", "continue", "strain_to_infodict", "[", "strain_id", "]", ".", "update", "(", "{", "'aa_count_{}'", ".", "format", "(", "k", ")", ":", "v", "for", "k", ",", "v", "in", "seqprop_to_analyze", ".", "annotations", "[", "'amino_acids_content-biop'", "]", ".", "items", "(", ")", "}", ")", "# [ALL] aa_count_total", "strain_to_infodict", "[", "strain_id", "]", "[", "'aa_count_total'", "]", "=", "seqprop_to_analyze", ".", "seq_len", "###### Calculate subsequence properties ######", "for", "prop", ",", "propdict", "in", "all_protein_subseqs", ".", "items", "(", ")", ":", "strain_to_infodict", "[", "strain_id", "]", ".", "update", "(", "protein", ".", "get_subseq_props", "(", "property_dict", "=", "propdict", ",", "property_name", "=", "prop", ",", "seqprop", "=", "seqprop_to_analyze", ")", ")", "protein_df", "=", "pd", ".", "DataFrame", "(", "strain_to_infodict", ")", "protein_df", ".", "reset_index", "(", ")", ".", "to_feather", "(", "protein_df_outfile", ")", "return", "protein_pickle_path", ",", "protein_df_outfile" ]

[ "Writes", "out", "a", "feather", "file", "for", "a", "PROTEIN", "counting", "amino", "acid", "occurences", "for", "ALL", "STRAINS", "along", "with", "SUBSEQUENCES" ]

[ "def", "render_linked_css", "(", "self", ",", "css_files", ":", "Iterable", "[", "str", "]", ")", "->", "str", ":", "paths", "=", "[", "]", "unique_paths", "=", "set", "(", ")", "# type: Set[str]", "for", "path", "in", "css_files", ":", "if", "not", "is_absolute", "(", "path", ")", ":", "path", "=", "self", ".", "static_url", "(", "path", ")", "if", "path", "not", "in", "unique_paths", ":", "paths", ".", "append", "(", "path", ")", "unique_paths", ".", "add", "(", "path", ")", "return", "\"\"", ".", "join", "(", "'<link href=\"'", "+", "escape", ".", "xhtml_escape", "(", "p", ")", "+", "'\" '", "'type=\"text/css\" rel=\"stylesheet\"/>'", "for", "p", "in", "paths", ")" ]

[ "Default", "method", "used", "to", "render", "the", "final", "css", "links", "for", "the", "rendered", "webpage", "." ]

[ "def", "_escape_headers", "(", "self", ",", "headers", ")", ":", "for", "key", ",", "val", "in", "headers", ".", "items", "(", ")", ":", "try", ":", "val", "=", "val", ".", "replace", "(", "'\\\\'", ",", "'\\\\\\\\'", ")", ".", "replace", "(", "'\\n'", ",", "'\\\\n'", ")", ".", "replace", "(", "':'", ",", "'\\\\c'", ")", ".", "replace", "(", "'\\r'", ",", "'\\\\r'", ")", "except", ":", "pass", "headers", "[", "key", "]", "=", "val" ]

[ ":", "param", "dict", "(", "str", "str", ")", "headers", ":" ]

[ "def", "remove_artifacts_seqs", "(", "seqs_fp", ",", "ref_fp", ",", "working_dir", ",", "ref_db_fp", ",", "negate", "=", "False", ",", "threads", "=", "1", ",", "verbose", "=", "False", ",", "sim_thresh", "=", "None", ",", "coverage_thresh", "=", "None", ")", ":", "logger", "=", "logging", ".", "getLogger", "(", "__name__", ")", "logger", ".", "info", "(", "'remove_artifacts_seqs file %s'", "%", "seqs_fp", ")", "if", "stat", "(", "seqs_fp", ")", ".", "st_size", "==", "0", ":", "logger", ".", "warn", "(", "'file %s has size 0, continuing'", "%", "seqs_fp", ")", "return", "None", ",", "0", ",", "[", "]", "if", "coverage_thresh", "is", "None", ":", "if", "negate", ":", "coverage_thresh", "=", "0.95", "*", "100", "else", ":", "coverage_thresh", "=", "0.5", "*", "100", "if", "sim_thresh", "is", "None", ":", "if", "negate", ":", "sim_thresh", "=", "0.95", "*", "100", "else", ":", "sim_thresh", "=", "0.65", "*", "100", "# the minimal average bitscore per nucleotide", "bitscore_thresh", "=", "0.65", "output_fp", "=", "join", "(", "working_dir", ",", "\"%s.no_artifacts\"", "%", "basename", "(", "seqs_fp", ")", ")", "blast_output", "=", "join", "(", "working_dir", ",", "'%s.sortmerna'", "%", "basename", "(", "seqs_fp", ")", ")", "aligned_seq_ids", "=", "set", "(", ")", "for", "i", ",", "db", "in", "enumerate", "(", "ref_fp", ")", ":", "logger", ".", "debug", "(", "'running on ref_fp %s working dir %s refdb_fp %s seqs %s'", "%", "(", "db", ",", "working_dir", ",", "ref_db_fp", "[", "i", "]", ",", "seqs_fp", ")", ")", "# run SortMeRNA", "# we use -e 100 to remove E-value based filtering by sortmerna", "# since we use bitscore/identity/coverage filtering instead", "params", "=", "[", "'sortmerna'", ",", "'--reads'", ",", "seqs_fp", ",", "'--ref'", ",", "'%s,%s'", "%", "(", "db", ",", "ref_db_fp", "[", "i", "]", ")", ",", "'--aligned'", ",", "blast_output", ",", "'--blast'", ",", "'3'", ",", "'--best'", ",", "'1'", ",", "'--print_all_reads'", ",", "'-v'", ",", "'-e'", ",", "'100'", "]", "sout", ",", "serr", ",", "res", "=", "_system_call", "(", "params", ")", "if", "not", "res", "==", "0", ":", "logger", ".", "error", "(", "'sortmerna error on file %s'", "%", "seqs_fp", ")", "logger", ".", "error", "(", "'stdout : %s'", "%", "sout", ")", "logger", ".", "error", "(", "'stderr : %s'", "%", "serr", ")", "return", "output_fp", ",", "0", ",", "[", "]", "blast_output_filename", "=", "'%s.blast'", "%", "blast_output", "with", "open", "(", "blast_output_filename", ",", "'r'", ")", "as", "bfl", ":", "for", "line", "in", "bfl", ":", "line", "=", "line", ".", "strip", "(", ")", ".", "split", "(", "'\\t'", ")", "# if * means no match", "if", "line", "[", "1", "]", "==", "'*'", ":", "continue", "# check if % identity[2] and coverage[13] are large enough", "if", "(", "float", "(", "line", "[", "2", "]", ")", ">=", "sim_thresh", ")", "and", "(", "float", "(", "line", "[", "13", "]", ")", ">=", "coverage_thresh", ")", "and", "(", "float", "(", "line", "[", "11", "]", ")", ">=", "bitscore_thresh", "*", "len", "(", "line", "[", "0", "]", ")", ")", ":", "aligned_seq_ids", ".", "add", "(", "line", "[", "0", "]", ")", "if", "negate", ":", "def", "op", "(", "x", ")", ":", "return", "x", "not", "in", "aligned_seq_ids", "else", ":", "def", "op", "(", "x", ")", ":", "return", "x", "in", "aligned_seq_ids", "# if negate = False, only output sequences", "# matching to at least one of the databases", "totalseqs", "=", "0", "okseqs", "=", "0", "badseqs", "=", "0", "with", "open", "(", "output_fp", ",", "'w'", ")", "as", "out_f", ":", "for", "label", ",", "seq", "in", "sequence_generator", "(", "seqs_fp", ")", ":", "totalseqs", "+=", "1", "label", "=", "label", ".", "split", "(", ")", "[", "0", "]", "if", "op", "(", "label", ")", ":", "out_f", ".", "write", "(", "\">%s\\n%s\\n\"", "%", "(", "label", ",", "seq", ")", ")", "okseqs", "+=", "1", "else", ":", "badseqs", "+=", "1", "logger", ".", "info", "(", "'total sequences %d, passing sequences %d, '", "'failing sequences %d'", "%", "(", "totalseqs", ",", "okseqs", ",", "badseqs", ")", ")", "return", "output_fp", ",", "okseqs", ",", "[", "blast_output_filename", "]" ]

[ "Remove", "artifacts", "from", "FASTA", "file", "using", "SortMeRNA", "." ]

[ "def", "get_secret", "(", "key", ",", "*", "args", ",", "*", "*", "kwargs", ")", ":", "env_value", "=", "os", ".", "environ", ".", "get", "(", "key", ".", "replace", "(", "'.'", ",", "'_'", ")", ".", "upper", "(", ")", ")", "if", "not", "env_value", ":", "# Backwards compatibility: the deprecated secrets vault", "return", "_get_secret_from_vault", "(", "key", ",", "*", "args", ",", "*", "*", "kwargs", ")", "return", "env_value" ]

[ "Retrieves", "a", "secret", "." ]

[ "def", "get_base_url", "(", "webdriver", ")", ":", "current_url", "=", "webdriver", ".", "current_url", "try", ":", "return", "re", ".", "findall", "(", "\"^[^/]+//[^/$]+\"", ",", "current_url", ")", "[", "0", "]", "except", ":", "raise", "RuntimeError", "(", "u", "(", "\"Unable to process base url: {0}\"", ")", ".", "format", "(", "current_url", ")", ")" ]

[ "Get", "the", "current", "base", "URL", "." ]

[ "def", "subscribeAsync", "(", "self", ",", "topic", ",", "QoS", ",", "ackCallback", "=", "None", ",", "messageCallback", "=", "None", ")", ":", "return", "self", ".", "_mqtt_core", ".", "subscribe_async", "(", "topic", ",", "QoS", ",", "ackCallback", ",", "messageCallback", ")" ]

[ "**", "Description", "**" ]

[ "def", "format_checksum", "(", "checksum_pyxb", ")", ":", "return", "'{}/{}'", ".", "format", "(", "checksum_pyxb", ".", "algorithm", ".", "upper", "(", ")", ".", "replace", "(", "'-'", ",", "''", ")", ",", "checksum_pyxb", ".", "value", "(", ")", ".", "lower", "(", ")", ")" ]

[ "Create", "string", "representation", "of", "a", "PyXB", "Checksum", "object", "." ]

[ "def", "public_dsn", "(", "dsn", ")", ":", "m", "=", "RE_DSN", ".", "match", "(", "dsn", ")", "if", "not", "m", ":", "log", ".", "error", "(", "'Unable to parse Sentry DSN'", ")", "public", "=", "'{scheme}://{client_id}@{domain}/{site_id}'", ".", "format", "(", "*", "*", "m", ".", "groupdict", "(", ")", ")", "return", "public" ]

[ "Transform", "a", "standard", "Sentry", "DSN", "into", "a", "public", "one" ]

[ "def", "get_version", "(", "pep440", "=", "False", ")", ":", "git_version", "=", "format_git_describe", "(", "call_git_describe", "(", ")", ",", "pep440", "=", "pep440", ")", "if", "git_version", "is", "None", ":", "# not a git repository", "return", "read_release_version", "(", ")", "return", "git_version" ]

[ "Tracks", "the", "version", "number", "." ]

[ "def", "chirp", "(", "fmin", ",", "fmax", ",", "sr", "=", "22050", ",", "length", "=", "None", ",", "duration", "=", "None", ",", "linear", "=", "False", ",", "phi", "=", "None", ")", ":", "if", "fmin", "is", "None", "or", "fmax", "is", "None", ":", "raise", "ParameterError", "(", "'both \"fmin\" and \"fmax\" must be provided'", ")", "# Compute signal duration", "period", "=", "1.0", "/", "sr", "if", "length", "is", "None", ":", "if", "duration", "is", "None", ":", "raise", "ParameterError", "(", "'either \"length\" or \"duration\" must be provided'", ")", "else", ":", "duration", "=", "period", "*", "length", "if", "phi", "is", "None", ":", "phi", "=", "-", "np", ".", "pi", "*", "0.5", "method", "=", "'linear'", "if", "linear", "else", "'logarithmic'", "return", "scipy", ".", "signal", ".", "chirp", "(", "np", ".", "arange", "(", "duration", ",", "step", "=", "period", ")", ",", "fmin", ",", "duration", ",", "fmax", ",", "method", "=", "method", ",", "phi", "=", "phi", "/", "np", ".", "pi", "*", "180", ",", "# scipy.signal.chirp uses degrees for phase offset", ")" ]

[ "Returns", "a", "chirp", "signal", "that", "goes", "from", "frequency", "fmin", "to", "frequency", "fmax" ]

[ "def", "swap", "(", "self", ",", "old_chunks", ",", "new_chunk", ")", ":", "indexes", "=", "[", "self", ".", "index", "(", "chunk", ")", "for", "chunk", "in", "old_chunks", "]", "del", "self", "[", "indexes", "[", "0", "]", ":", "indexes", "[", "-", "1", "]", "+", "1", "]", "self", ".", "insert", "(", "indexes", "[", "0", "]", ",", "new_chunk", ")" ]

[ "Swaps", "old", "consecutive", "chunks", "with", "new", "chunk", "." ]

[ "def", "is_sharable", "(", "self", ")", ":", "return", "bool", "(", "self", ".", "sharable", "and", "all", "(", "x", ".", "is_sharable", "(", ")", "for", "x", "in", "self", ".", "elements", ")", ")" ]

[ "Can", "only", "be", "sharable", "if", "marked", "as", "such", "and", "no", "child", "element", "is", "blocking", "sharing", "due", "to", "security", "reasons", "." ]

[ "def", "emit", "(", "self", ",", "signal", ",", "message", "=", "'__nomessagetoken__'", ")", ":", "# call pre-emit hooks", "if", "signal", "==", "'log'", ":", "self", ".", "log_backend", ".", "info", "(", "message", ")", "elif", "signal", "==", "'warn'", ":", "self", ".", "log_backend", ".", "warn", "(", "message", ")", "elif", "signal", "==", "'error'", ":", "self", ".", "log_backend", ".", "error", "(", "message", ")", "return", "self", ".", "emit_to_frontend", "(", "signal", ",", "message", ")" ]

[ "Emit", "a", "signal", "to", "the", "frontend", "." ]

[ "def", "parse_segment", "(", "text", ")", ":", "if", "not", "len", "(", "text", ")", ":", "return", "NoopQuerySegment", "(", ")", "q", "=", "QuerySegment", "(", ")", "# First we need to split the segment into key/value pairs. This is done", "# by attempting to split the sequence for each equality comparison. Then", "# discard any that did not split properly. Then chose the smallest key", "# (greedily chose the first comparator we encounter in the string)", "# followed by the smallest value (greedily chose the largest comparator", "# possible.)", "# translate into [('=', 'foo=bar')]", "equalities", "=", "zip", "(", "constants", ".", "OPERATOR_EQUALITIES", ",", "itertools", ".", "repeat", "(", "text", ")", ")", "# Translate into [('=', ['foo', 'bar'])]", "equalities", "=", "map", "(", "lambda", "x", ":", "(", "x", "[", "0", "]", ",", "x", "[", "1", "]", ".", "split", "(", "x", "[", "0", "]", ",", "1", ")", ")", ",", "equalities", ")", "# Remove unsplit entries and translate into [('=': ['foo', 'bar'])]", "# Note that the result from this stage is iterated over twice.", "equalities", "=", "list", "(", "filter", "(", "lambda", "x", ":", "len", "(", "x", "[", "1", "]", ")", ">", "1", ",", "equalities", ")", ")", "# Get the smallest key and use the length of that to remove other items", "key_len", "=", "len", "(", "min", "(", "(", "x", "[", "1", "]", "[", "0", "]", "for", "x", "in", "equalities", ")", ",", "key", "=", "len", ")", ")", "equalities", "=", "filter", "(", "lambda", "x", ":", "len", "(", "x", "[", "1", "]", "[", "0", "]", ")", "==", "key_len", ",", "equalities", ")", "# Get the smallest value length. thus we have the earliest key and the", "# smallest value.", "op", ",", "(", "key", ",", "value", ")", "=", "min", "(", "equalities", ",", "key", "=", "lambda", "x", ":", "len", "(", "x", "[", "1", "]", "[", "1", "]", ")", ")", "key", ",", "directive", "=", "parse_directive", "(", "key", ")", "if", "directive", ":", "op", "=", "constants", ".", "OPERATOR_EQUALITY_FALLBACK", "q", ".", "directive", "=", "directive", "# Process negation. This comes in both foo.not= and foo!= forms.", "path", "=", "key", ".", "split", "(", "constants", ".", "SEP_PATH", ")", "last", "=", "path", "[", "-", "1", "]", "# Check for !=", "if", "last", ".", "endswith", "(", "constants", ".", "OPERATOR_NEGATION", ")", ":", "last", "=", "last", "[", ":", "-", "1", "]", "q", ".", "negated", "=", "not", "q", ".", "negated", "# Check for foo.not=", "if", "last", "==", "constants", ".", "PATH_NEGATION", ":", "path", ".", "pop", "(", "-", "1", ")", "q", ".", "negated", "=", "not", "q", ".", "negated", "q", ".", "values", "=", "value", ".", "split", "(", "constants", ".", "SEP_VALUE", ")", "# Check for suffixed operators (foo.gte=bar). Prioritize suffixed", "# entries over actual equality checks.", "if", "path", "[", "-", "1", "]", "in", "constants", ".", "OPERATOR_SUFFIXES", ":", "# The case where foo.gte<=bar, which obviously makes no sense.", "if", "op", "not", "in", "constants", ".", "OPERATOR_FALLBACK", ":", "raise", "ValueError", "(", "'Both path-style operator and equality style operator '", "'provided. Please provide only a single style operator.'", ")", "q", ".", "operator", "=", "constants", ".", "OPERATOR_SUFFIX_MAP", "[", "path", "[", "-", "1", "]", "]", "path", ".", "pop", "(", "-", "1", ")", "else", ":", "q", ".", "operator", "=", "constants", ".", "OPERATOR_EQUALITY_MAP", "[", "op", "]", "if", "not", "len", "(", "path", ")", ":", "raise", "ValueError", "(", "'No attribute navigation path provided.'", ")", "q", ".", "path", "=", "path", "return", "q" ]

[ "we", "expect", "foo", "=", "bar" ]

[ "def", "_printed_len", "(", "some_string", ")", ":", "return", "len", "(", "[", "x", "for", "x", "in", "ANSI_ESC_RE", ".", "sub", "(", "''", ",", "some_string", ")", "if", "x", "in", "string", ".", "printable", "]", ")" ]

[ "Compute", "the", "visible", "length", "of", "the", "string", "when", "printed", "." ]

[ "def", "summarize_taxa", "(", "biom", ")", ":", "tamtcounts", "=", "defaultdict", "(", "int", ")", "tot_seqs", "=", "0.0", "for", "row", ",", "col", ",", "amt", "in", "biom", "[", "'data'", "]", ":", "tot_seqs", "+=", "amt", "rtax", "=", "biom", "[", "'rows'", "]", "[", "row", "]", "[", "'metadata'", "]", "[", "'taxonomy'", "]", "for", "i", ",", "t", "in", "enumerate", "(", "rtax", ")", ":", "t", "=", "t", ".", "strip", "(", ")", "if", "i", "==", "len", "(", "rtax", ")", "-", "1", "and", "len", "(", "t", ")", ">", "3", "and", "len", "(", "rtax", "[", "-", "1", "]", ")", ">", "3", ":", "t", "=", "'s__'", "+", "rtax", "[", "i", "-", "1", "]", ".", "strip", "(", ")", ".", "split", "(", "'_'", ")", "[", "-", "1", "]", "+", "'_'", "+", "t", ".", "split", "(", "'_'", ")", "[", "-", "1", "]", "tamtcounts", "[", "t", "]", "+=", "amt", "lvlData", "=", "{", "lvl", ":", "levelData", "(", "tamtcounts", ",", "tot_seqs", ",", "lvl", ")", "for", "lvl", "in", "[", "'k'", ",", "'p'", ",", "'c'", ",", "'o'", ",", "'f'", ",", "'g'", ",", "'s'", "]", "}", "return", "tot_seqs", ",", "lvlData" ]

[ "Given", "an", "abundance", "table", "group", "the", "counts", "by", "every", "taxonomic", "level", "." ]

[ "def", "render", "(", "self", ",", "context", ",", "instance", ",", "placeholder", ")", ":", "context", "=", "super", "(", "SquareCheckoutFormPlugin", ",", "self", ")", ".", "render", "(", "context", ",", "instance", ",", "placeholder", ")", "context", ".", "update", "(", "{", "'squareApplicationId'", ":", "getattr", "(", "settings", ",", "'SQUARE_APPLICATION_ID'", ",", "''", ")", ",", "}", ")", "return", "context" ]

[ "Add", "the", "cart", "-", "specific", "context", "to", "this", "form" ]

[ "def", "strip_rx_flags", "(", "self", ",", "idx", ")", ":", "rx_flags", "=", "collections", ".", "namedtuple", "(", "'rx_flags'", ",", "[", "'reserved'", ",", "'badplcp'", "]", ")", "idx", "=", "Radiotap", ".", "align", "(", "idx", ",", "2", ")", "flags", ",", "=", "struct", ".", "unpack_from", "(", "'<H'", ",", "self", ".", "_rtap", ",", "idx", ")", "flag_bits", "=", "format", "(", "flags", ",", "'08b'", ")", "[", ":", ":", "-", "1", "]", "rx_flags", ".", "reserved", "=", "int", "(", "flag_bits", "[", "0", "]", ")", "rx_flags", ".", "badplcp", "=", "int", "(", "flag_bits", "[", "1", "]", ")", "return", "idx", "+", "2", ",", "rx_flags" ]

[ "strip", "(", "2", "byte", ")", "radiotap", ".", "rxflags", ":", "idx", ":", "int", ":", "return", ":", "int", "idx", ":", "return", ":", "collections", ".", "namedtuple" ]

[ "def", "prepare_psf_model", "(", "psfmodel", ",", "xname", "=", "None", ",", "yname", "=", "None", ",", "fluxname", "=", "None", ",", "renormalize_psf", "=", "True", ")", ":", "if", "xname", "is", "None", ":", "xinmod", "=", "models", ".", "Shift", "(", "0", ",", "name", "=", "'x_offset'", ")", "xname", "=", "'offset_0'", "else", ":", "xinmod", "=", "models", ".", "Identity", "(", "1", ")", "xname", "=", "xname", "+", "'_2'", "xinmod", ".", "fittable", "=", "True", "if", "yname", "is", "None", ":", "yinmod", "=", "models", ".", "Shift", "(", "0", ",", "name", "=", "'y_offset'", ")", "yname", "=", "'offset_1'", "else", ":", "yinmod", "=", "models", ".", "Identity", "(", "1", ")", "yname", "=", "yname", "+", "'_2'", "yinmod", ".", "fittable", "=", "True", "outmod", "=", "(", "xinmod", "&", "yinmod", ")", "|", "psfmodel", "if", "fluxname", "is", "None", ":", "outmod", "=", "outmod", "*", "models", ".", "Const2D", "(", "1", ",", "name", "=", "'flux_scaling'", ")", "fluxname", "=", "'amplitude_3'", "else", ":", "fluxname", "=", "fluxname", "+", "'_2'", "if", "renormalize_psf", ":", "# we do the import here because other machinery works w/o scipy", "from", "scipy", "import", "integrate", "integrand", "=", "integrate", ".", "dblquad", "(", "psfmodel", ",", "-", "np", ".", "inf", ",", "np", ".", "inf", ",", "lambda", "x", ":", "-", "np", ".", "inf", ",", "lambda", "x", ":", "np", ".", "inf", ")", "[", "0", "]", "normmod", "=", "models", ".", "Const2D", "(", "1.", "/", "integrand", ",", "name", "=", "'renormalize_scaling'", ")", "outmod", "=", "outmod", "*", "normmod", "# final setup of the output model - fix all the non-offset/scale", "# parameters", "for", "pnm", "in", "outmod", ".", "param_names", ":", "outmod", ".", "fixed", "[", "pnm", "]", "=", "pnm", "not", "in", "(", "xname", ",", "yname", ",", "fluxname", ")", "# and set the names so that BasicPSFPhotometry knows what to do", "outmod", ".", "xname", "=", "xname", "outmod", ".", "yname", "=", "yname", "outmod", ".", "fluxname", "=", "fluxname", "# now some convenience aliases if reasonable", "outmod", ".", "psfmodel", "=", "outmod", "[", "2", "]", "if", "'x_0'", "not", "in", "outmod", ".", "param_names", "and", "'y_0'", "not", "in", "outmod", ".", "param_names", ":", "outmod", ".", "x_0", "=", "getattr", "(", "outmod", ",", "xname", ")", "outmod", ".", "y_0", "=", "getattr", "(", "outmod", ",", "yname", ")", "if", "'flux'", "not", "in", "outmod", ".", "param_names", ":", "outmod", ".", "flux", "=", "getattr", "(", "outmod", ",", "fluxname", ")", "return", "outmod" ]

[ "Convert", "a", "2D", "PSF", "model", "to", "one", "suitable", "for", "use", "with", "BasicPSFPhotometry", "or", "its", "subclasses", "." ]

[ "def", "retrieve_list", "(", "self", ",", "session", ",", "filters", ",", "*", "args", ",", "*", "*", "kwargs", ")", ":", "query", "=", "self", ".", "queryset", "(", "session", ")", "translator", "=", "IntegerField", "(", "'tmp'", ")", "pagination_count", "=", "translator", ".", "translate", "(", "filters", ".", "pop", "(", "self", ".", "pagination_count_query_arg", ",", "self", ".", "paginate_by", ")", ")", "pagination_pk", "=", "translator", ".", "translate", "(", "filters", ".", "pop", "(", "self", ".", "pagination_pk_query_arg", ",", "1", ")", ")", "pagination_pk", "-=", "1", "# logic works zero based. Pagination shouldn't be though", "query", "=", "query", ".", "filter_by", "(", "*", "*", "filters", ")", "if", "pagination_pk", ":", "query", "=", "query", ".", "offset", "(", "pagination_pk", "*", "pagination_count", ")", "if", "pagination_count", ":", "query", "=", "query", ".", "limit", "(", "pagination_count", "+", "1", ")", "count", "=", "query", ".", "count", "(", ")", "next_link", "=", "None", "previous_link", "=", "None", "if", "count", ">", "pagination_count", ":", "next_link", "=", "{", "self", ".", "pagination_pk_query_arg", ":", "pagination_pk", "+", "2", ",", "self", ".", "pagination_count_query_arg", ":", "pagination_count", "}", "if", "pagination_pk", ">", "0", ":", "previous_link", "=", "{", "self", ".", "pagination_pk_query_arg", ":", "pagination_pk", ",", "self", ".", "pagination_count_query_arg", ":", "pagination_count", "}", "field_dict", "=", "self", ".", "dot_field_list_to_dict", "(", "self", ".", "list_fields", ")", "props", "=", "self", ".", "serialize_model", "(", "query", "[", ":", "pagination_count", "]", ",", "field_dict", "=", "field_dict", ")", "meta", "=", "dict", "(", "links", "=", "dict", "(", "next", "=", "next_link", ",", "previous", "=", "previous_link", ")", ")", "return", "props", ",", "meta" ]

[ "Retrieves", "a", "list", "of", "the", "model", "for", "this", "manager", ".", "It", "is", "restricted", "by", "the", "filters", "provided", "." ]

[ "def", "gen_req_sfc", "(", "lat_x", ",", "lon_x", ",", "start", ",", "end", ",", "grid", "=", "[", "0.125", ",", "0.125", "]", ",", "scale", "=", "0", ")", ":", "# scale is a factor to rescale grid size", "size", "=", "grid", "[", "0", "]", "*", "scale", "# generate pd.Series for timestamps", "ser_datetime", "=", "pd", ".", "date_range", "(", "start", ",", "end", ",", "freq", "=", "'1h'", ")", ".", "to_series", "(", ")", "# surface requests", "lat_c", ",", "lon_c", "=", "(", "roundPartial", "(", "x", ",", "grid", "[", "0", "]", ")", "for", "x", "in", "[", "lat_x", ",", "lon_x", "]", ")", "area", "=", "[", "lat_c", "+", "size", ",", "lon_c", "-", "size", ",", "lat_c", "-", "size", ",", "lon_c", "+", "size", "]", "dict_req_sfc", "=", "{", "'variable'", ":", "list_var_sfc", ",", "'product_type'", ":", "'reanalysis'", ",", "'area'", ":", "area", ",", "'grid'", ":", "grid", ",", "'format'", ":", "'netcdf'", "}", "list_dict_req_sfc", "=", "[", "{", "*", "*", "dict_req_sfc", ",", "*", "*", "dict_dt", "}", "for", "dict_dt", "in", "list", "(", "gen_dict_dt_sub", "(", "ser_datetime", ")", ".", "values", "(", ")", ")", "]", "dict_req_sfc", "=", "{", "gen_fn", "(", "dict_req", ")", ":", "gen_dict_proc", "(", "dict_req", ")", "for", "dict_req", "in", "list_dict_req_sfc", "}", "return", "dict_req_sfc" ]

[ "generate", "a", "dict", "of", "reqs", "kwargs", "for", "(", "lat_x", "lon_x", ")", "spanning", "[", "start", "end", "]" ]

[ "def", "maps_get_default_rules_output_rules_groupname", "(", "self", ",", "*", "*", "kwargs", ")", ":", "config", "=", "ET", ".", "Element", "(", "\"config\"", ")", "maps_get_default_rules", "=", "ET", ".", "Element", "(", "\"maps_get_default_rules\"", ")", "config", "=", "maps_get_default_rules", "output", "=", "ET", ".", "SubElement", "(", "maps_get_default_rules", ",", "\"output\"", ")", "rules", "=", "ET", ".", "SubElement", "(", "output", ",", "\"rules\"", ")", "groupname", "=", "ET", ".", "SubElement", "(", "rules", ",", "\"groupname\"", ")", "groupname", ".", "text", "=", "kwargs", ".", "pop", "(", "'groupname'", ")", "callback", "=", "kwargs", ".", "pop", "(", "'callback'", ",", "self", ".", "_callback", ")", "return", "callback", "(", "config", ")" ]

[ "Auto", "Generated", "Code" ]

[ "def", "qteToBeKilled", "(", "self", ")", ":", "self", ".", "clearHighlighting", "(", ")", "self", ".", "qteWidget", ".", "qteSetLexer", "(", "self", ".", "originalLexer", ")", "self", ".", "qteText", ".", "textChanged", ".", "disconnect", "(", "self", ".", "qteTextChanged", ")" ]

[ "Remove", "all", "selections", "and", "install", "the", "original", "lexer", "." ]

[ "def", "_get_platlib_dir", "(", "cmd", ")", ":", "plat_specifier", "=", "'.{0}-{1}'", ".", "format", "(", "cmd", ".", "plat_name", ",", "sys", ".", "version", "[", "0", ":", "3", "]", ")", "return", "os", ".", "path", ".", "join", "(", "cmd", ".", "build_base", ",", "'lib'", "+", "plat_specifier", ")" ]

[ "Given", "a", "build", "command", "return", "the", "name", "of", "the", "appropriate", "platform", "-", "specific", "build", "subdirectory", "directory", "(", "e", ".", "g", ".", "build", "/", "lib", ".", "linux", "-", "x86_64", "-", "2", ".", "7", ")" ]

[ "def", "dict_to_etree", "(", "source", ",", "root_tag", "=", "None", ")", ":", "def", "dict_to_etree_recursive", "(", "source", ",", "parent", ")", ":", "if", "hasattr", "(", "source", ",", "'keys'", ")", ":", "for", "key", ",", "value", "in", "source", ".", "iteritems", "(", ")", ":", "sub", "=", "ET", ".", "SubElement", "(", "parent", ",", "key", ")", "dict_to_etree_recursive", "(", "value", ",", "sub", ")", "elif", "isinstance", "(", "source", ",", "list", ")", ":", "for", "element", "in", "source", ":", "dict_to_etree_recursive", "(", "element", ",", "parent", ")", "else", ":", "# TODO: Add feature to include xml literals as special objects or a etree subtree", "parent", ".", "text", "=", "source", "if", "root_tag", "is", "None", ":", "if", "len", "(", "source", ")", "==", "1", ":", "root_tag", "=", "source", ".", "keys", "(", ")", "[", "0", "]", "source", "=", "source", "[", "root_tag", "]", "else", ":", "roots", "=", "[", "]", "for", "tag", ",", "content", "in", "source", ".", "iteritems", "(", ")", ":", "root", "=", "ET", ".", "Element", "(", "tag", ")", "dict_to_etree_recursive", "(", "content", ",", "root", ")", "roots", ".", "append", "(", "root", ")", "return", "roots", "root", "=", "ET", ".", "Element", "(", "root_tag", ")", "dict_to_etree_recursive", "(", "source", ",", "root", ")", "return", "root" ]

[ "Recursively", "load", "dict", "/", "list", "representation", "of", "an", "XML", "tree", "into", "an", "etree", "representation", "." ]

[ "def", "to_pretty_json", "(", "self", ",", "ignore_none", ":", "bool", "=", "True", ",", "ignore_empty", ":", "bool", "=", "False", ")", "->", "str", ":", "return", "self", ".", "to_json", "(", "4", ",", "ignore_none", ",", "ignore_empty", ")" ]

[ "From", "instance", "to", "pretty", "json", "string" ]

[ "def", "import_taskfile", "(", "self", ",", "refobj", ",", "taskfileinfo", ")", ":", "inter", "=", "self", ".", "get_typ_interface", "(", "self", ".", "get_typ", "(", "refobj", ")", ")", "inter", ".", "import_taskfile", "(", "refobj", ",", "taskfileinfo", ")" ]

[ "Import", "the", "given", "taskfileinfo", "and", "update", "the", "refobj" ]

[ "def", "pick_free_port", "(", "hostname", "=", "REDIRECT_HOST", ",", "port", "=", "0", ")", ":", "import", "socket", "s", "=", "socket", ".", "socket", "(", "socket", ".", "AF_INET", ",", "socket", ".", "SOCK_STREAM", ")", "try", ":", "s", ".", "bind", "(", "(", "hostname", ",", "port", ")", ")", "# port=0 finds an open port", "except", "OSError", "as", "e", ":", "log", ".", "warning", "(", "\"Could not bind to %s:%s %s\"", ",", "hostname", ",", "port", ",", "e", ")", "if", "port", "==", "0", ":", "print", "(", "'Unable to find an open port for authentication.'", ")", "raise", "AuthenticationException", "(", "e", ")", "else", ":", "return", "pick_free_port", "(", "hostname", ",", "0", ")", "addr", ",", "port", "=", "s", ".", "getsockname", "(", ")", "s", ".", "close", "(", ")", "return", "port" ]

[ "Try", "to", "bind", "a", "port", ".", "Default", "=", "0", "selects", "a", "free", "port", "." ]

[ "def", "output_interval_histogram", "(", "self", ",", "histogram", ",", "start_time_stamp_sec", "=", "0", ",", "end_time_stamp_sec", "=", "0", ",", "max_value_unit_ratio", "=", "1000000.0", ")", ":", "if", "not", "start_time_stamp_sec", ":", "start_time_stamp_sec", "=", "(", "histogram", ".", "get_start_time_stamp", "(", ")", "-", "self", ".", "base_time", ")", "/", "1000.0", "if", "not", "end_time_stamp_sec", ":", "end_time_stamp_sec", "=", "(", "histogram", ".", "get_end_time_stamp", "(", ")", "-", "self", ".", "base_time", ")", "/", "1000.0", "cpayload", "=", "histogram", ".", "encode", "(", ")", "self", ".", "log", ".", "write", "(", "\"%f,%f,%f,%s\\n\"", "%", "(", "start_time_stamp_sec", ",", "end_time_stamp_sec", "-", "start_time_stamp_sec", ",", "histogram", ".", "get_max_value", "(", ")", "//", "max_value_unit_ratio", ",", "cpayload", ".", "decode", "(", "'utf-8'", ")", ")", ")" ]

[ "Output", "an", "interval", "histogram", "with", "the", "given", "timestamp", "and", "a", "configurable", "maxValueUnitRatio", ".", "(", "note", "that", "the", "specified", "timestamp", "will", "be", "used", "and", "the", "timestamp", "in", "the", "actual", "histogram", "will", "be", "ignored", ")", ".", "The", "max", "value", "reported", "with", "the", "interval", "line", "will", "be", "scaled", "by", "the", "given", "max_value_unit_ratio", ".", "The", "histogram", "start", "and", "end", "timestamps", "are", "assumed", "to", "be", "in", "msec", "units", ".", "Logging", "will", "be", "in", "seconds", "realtive", "by", "a", "base", "time", "The", "default", "base", "time", "is", "0", "." ]

[ "def", "insert", "(", "self", ",", "matcher", ",", "obj", ")", ":", "current", "=", "self", ".", "subtree", "(", "matcher", ",", "True", ")", "#current.matchers[(obj, matcher)] = None", "if", "current", ".", "_use_dict", ":", "current", ".", "matchers_dict", "[", "(", "obj", ",", "matcher", ")", "]", "=", "None", "else", ":", "current", ".", "matchers_list", ".", "append", "(", "(", "obj", ",", "matcher", ")", ")", "return", "current" ]

[ "Insert", "a", "new", "matcher", ":", "param", "matcher", ":", "an", "EventMatcher", ":", "param", "obj", ":", "object", "to", "return" ]

[ "def", "ensure_dir_does_not_exist", "(", "*", "args", ")", ":", "path", "=", "os", ".", "path", ".", "join", "(", "*", "args", ")", "if", "os", ".", "path", ".", "isdir", "(", "path", ")", ":", "shutil", ".", "rmtree", "(", "path", ")" ]

[ "Ensures", "that", "the", "given", "directory", "does", "not", "exist", "." ]

[ "def", "select_by_ext", "(", "self", ",", "ext", ",", "recursive", "=", "True", ")", ":", "ext", "=", "[", "ext", ".", "strip", "(", ")", ".", "lower", "(", ")", "for", "ext", "in", "ensure_list", "(", "ext", ")", "]", "def", "filters", "(", "p", ")", ":", "return", "p", ".", "suffix", ".", "lower", "(", ")", "in", "ext", "return", "self", ".", "select_file", "(", "filters", ",", "recursive", ")" ]

[ "Select", "file", "path", "by", "extension", "." ]

[ "def", "equivalent_to", "(", "self", ",", "token", ")", ":", "return", "self", ".", "filter", "(", "character_id", "=", "token", ".", "character_id", ")", ".", "require_scopes_exact", "(", "token", ".", "scopes", ".", "all", "(", ")", ")", ".", "filter", "(", "models", ".", "Q", "(", "user", "=", "token", ".", "user", ")", "|", "models", ".", "Q", "(", "user__isnull", "=", "True", ")", ")", ".", "exclude", "(", "pk", "=", "token", ".", "pk", ")" ]

[ "Gets", "all", "tokens", "which", "match", "the", "character", "and", "scopes", "of", "a", "reference", "token", ":", "param", "token", ":", ":", "class", ":", "esi", ".", "models", ".", "Token", ":", "return", ":", ":", "class", ":", "esi", ".", "managers", ".", "TokenQueryset" ]

[ "def", "GetFormatSpecification", "(", "self", ")", ":", "format_specification", "=", "specification", ".", "FormatSpecification", "(", "self", ".", "type_indicator", ")", "# FAT volume header signature.", "format_specification", ".", "AddNewSignature", "(", "b'\\x55\\xaa'", ",", "offset", "=", "510", ")", "if", "definitions", ".", "PREFERRED_NTFS_BACK_END", "==", "self", ".", "TYPE_INDICATOR", ":", "# NTFS file system signature.", "format_specification", ".", "AddNewSignature", "(", "b'NTFS '", ",", "offset", "=", "3", ")", "# HFS boot block signature.", "format_specification", ".", "AddNewSignature", "(", "b'LK'", ",", "offset", "=", "0", ")", "# HFS master directory block signature.", "format_specification", ".", "AddNewSignature", "(", "b'BD'", ",", "offset", "=", "0", ")", "# HFS+ file system signature.", "format_specification", ".", "AddNewSignature", "(", "b'H+'", ",", "offset", "=", "1024", ")", "# HFSX file system signature.", "format_specification", ".", "AddNewSignature", "(", "b'HX'", ",", "offset", "=", "1024", ")", "# Ext file system signature.", "format_specification", ".", "AddNewSignature", "(", "b'\\x53\\xef'", ",", "offset", "=", "1080", ")", "# ISO9660 file system signature.", "format_specification", ".", "AddNewSignature", "(", "b'CD001'", ",", "offset", "=", "32769", ")", "# YAFFS file system signature.", "return", "format_specification" ]

[ "Retrieves", "the", "format", "specification", "." ]

[ "def", "get_root_families", "(", "self", ")", ":", "# Implemented from template for", "# osid.resource.BinHierarchySession.get_root_bins", "if", "self", ".", "_catalog_session", "is", "not", "None", ":", "return", "self", ".", "_catalog_session", ".", "get_root_catalogs", "(", ")", "return", "FamilyLookupSession", "(", "self", ".", "_proxy", ",", "self", ".", "_runtime", ")", ".", "get_families_by_ids", "(", "list", "(", "self", ".", "get_root_family_ids", "(", ")", ")", ")" ]

[ "Gets", "the", "root", "families", "in", "the", "family", "hierarchy", "." ]

[ "def", "read", "(", "self", ",", "amount", ":", "int", "=", "-", "1", ")", "->", "bytes", ":", "assert", "self", ".", "_state", "==", "ConnectionState", ".", "created", ",", "'Expect conn created. Got {}.'", ".", "format", "(", "self", ".", "_state", ")", "data", "=", "yield", "from", "self", ".", "run_network_operation", "(", "self", ".", "reader", ".", "read", "(", "amount", ")", ",", "close_timeout", "=", "self", ".", "_timeout", ",", "name", "=", "'Read'", ")", "return", "data" ]

[ "Read", "data", "." ]

[ "def", "segments", "(", "self", ")", ":", "for", "n", "in", "xrange", "(", "len", "(", "self", ".", "vertices", ")", "-", "1", ")", ":", "yield", "Line", "(", "self", ".", "vertices", "[", "n", "]", ",", "self", ".", "vertices", "[", "n", "+", "1", "]", ")", "yield", "Line", "(", "self", ".", "vertices", "[", "-", "1", "]", ",", "self", ".", "vertices", "[", "0", "]", ")" ]

[ "Return", "the", "Line", "segments", "that", "comprise", "this", "Polygon", "." ]

[ "def", "_mb_model", "(", "self", ",", "beta", ",", "mini_batch", ")", ":", "# Transform latent variables", "parm", "=", "np", ".", "array", "(", "[", "self", ".", "latent_variables", ".", "z_list", "[", "k", "]", ".", "prior", ".", "transform", "(", "beta", "[", "k", "]", ")", "for", "k", "in", "range", "(", "beta", ".", "shape", "[", "0", "]", ")", "]", ")", "rand_int", "=", "np", ".", "random", ".", "randint", "(", "low", "=", "0", ",", "high", "=", "self", ".", "data_length", "-", "mini_batch", "+", "1", ")", "sample", "=", "np", ".", "arange", "(", "start", "=", "rand_int", ",", "stop", "=", "rand_int", "+", "mini_batch", ")", "sampled_data", "=", "self", ".", "data", "[", "sample", "]", "Y", "=", "np", ".", "array", "(", "sampled_data", "[", "self", ".", "max_lag", ":", "]", ")", "X", "=", "np", ".", "ones", "(", "Y", ".", "shape", "[", "0", "]", ")", "scores", "=", "np", ".", "zeros", "(", "Y", ".", "shape", "[", "0", "]", ")", "lmda", "=", "np", ".", "ones", "(", "Y", ".", "shape", "[", "0", "]", ")", "*", "parm", "[", "0", "]", "theta", "=", "np", ".", "ones", "(", "Y", ".", "shape", "[", "0", "]", ")", "*", "parm", "[", "-", "1", "]", "# Loop over time series", "for", "t", "in", "range", "(", "0", ",", "Y", ".", "shape", "[", "0", "]", ")", ":", "if", "t", "<", "self", ".", "max_lag", ":", "lmda", "[", "t", "]", "=", "parm", "[", "0", "]", "/", "(", "1", "-", "np", ".", "sum", "(", "parm", "[", "1", ":", "(", "self", ".", "p", "+", "1", ")", "]", ")", ")", "theta", "[", "t", "]", "+=", "(", "parm", "[", "-", "3", "]", "-", "(", "1.0", "/", "parm", "[", "-", "3", "]", ")", ")", "*", "np", ".", "exp", "(", "lmda", "[", "t", "]", ")", "*", "(", "np", ".", "sqrt", "(", "parm", "[", "-", "2", "]", ")", "*", "sp", ".", "gamma", "(", "(", "parm", "[", "-", "2", "]", "-", "1.0", ")", "/", "2.0", ")", ")", "/", "(", "np", ".", "sqrt", "(", "np", ".", "pi", ")", "*", "sp", ".", "gamma", "(", "parm", "[", "-", "2", "]", "/", "2.0", ")", ")", "else", ":", "# Loop over GARCH terms", "for", "p_term", "in", "range", "(", "0", ",", "self", ".", "p", ")", ":", "lmda", "[", "t", "]", "+=", "parm", "[", "1", "+", "p_term", "]", "*", "lmda", "[", "t", "-", "p_term", "-", "1", "]", "# Loop over Score terms", "for", "q_term", "in", "range", "(", "0", ",", "self", ".", "q", ")", ":", "lmda", "[", "t", "]", "+=", "parm", "[", "1", "+", "self", ".", "p", "+", "q_term", "]", "*", "scores", "[", "t", "-", "q_term", "-", "1", "]", "if", "self", ".", "leverage", "is", "True", ":", "lmda", "[", "t", "]", "+=", "parm", "[", "-", "4", "]", "*", "np", ".", "sign", "(", "-", "(", "Y", "[", "t", "-", "1", "]", "-", "theta", "[", "t", "-", "1", "]", ")", ")", "*", "(", "scores", "[", "t", "-", "1", "]", "+", "1", ")", "theta", "[", "t", "]", "+=", "(", "parm", "[", "-", "3", "]", "-", "(", "1.0", "/", "parm", "[", "-", "3", "]", ")", ")", "*", "np", ".", "exp", "(", "lmda", "[", "t", "]", "/", "2.0", ")", "*", "(", "np", ".", "sqrt", "(", "parm", "[", "-", "2", "]", ")", "*", "sp", ".", "gamma", "(", "(", "parm", "[", "-", "2", "]", "-", "1.0", ")", "/", "2.0", ")", ")", "/", "(", "np", ".", "sqrt", "(", "np", ".", "pi", ")", "*", "sp", ".", "gamma", "(", "parm", "[", "-", "2", "]", "/", "2.0", ")", ")", "if", "(", "Y", "[", "t", "]", "-", "theta", "[", "t", "]", ")", ">=", "0", ":", "scores", "[", "t", "]", "=", "(", "(", "(", "parm", "[", "-", "2", "]", "+", "1.0", ")", "*", "np", ".", "power", "(", "Y", "[", "t", "]", "-", "theta", "[", "t", "]", ",", "2", ")", ")", "/", "float", "(", "np", ".", "power", "(", "parm", "[", "-", "3", "]", ",", "2", ")", "*", "parm", "[", "-", "2", "]", "*", "np", ".", "exp", "(", "lmda", "[", "t", "]", ")", "+", "np", ".", "power", "(", "Y", "[", "t", "]", "-", "theta", "[", "t", "]", ",", "2", ")", ")", ")", "-", "1.0", "else", ":", "scores", "[", "t", "]", "=", "(", "(", "(", "parm", "[", "-", "2", "]", "+", "1.0", ")", "*", "np", ".", "power", "(", "Y", "[", "t", "]", "-", "theta", "[", "t", "]", ",", "2", ")", ")", "/", "float", "(", "np", ".", "power", "(", "parm", "[", "-", "3", "]", ",", "-", "2", ")", "*", "parm", "[", "-", "2", "]", "*", "np", ".", "exp", "(", "lmda", "[", "t", "]", ")", "+", "np", ".", "power", "(", "Y", "[", "t", "]", "-", "theta", "[", "t", "]", ",", "2", ")", ")", ")", "-", "1.0", "return", "lmda", ",", "Y", ",", "scores", ",", "theta" ]

[ "Creates", "the", "structure", "of", "the", "model" ]

[ "def", "latlong", "(", "text", ")", ":", "nlat", ",", "nlon", "=", "text", ".", "split", "(", "','", ")", "return", "(", "float", "(", "nlat", ")", ",", "float", "(", "nlon", ")", ")" ]

[ "Chop", "a", "latlong", "string", "and", "return", "(", "float", "float", ")", ".", "Does", "not", "perform", "validation", "on", "the", "coordinates", "." ]

[ "def", "get_python_args", "(", "fname", ",", "python_args", ",", "interact", ",", "debug", ",", "end_args", ")", ":", "p_args", "=", "[", "]", "if", "python_args", "is", "not", "None", ":", "p_args", "+=", "python_args", ".", "split", "(", ")", "if", "interact", ":", "p_args", ".", "append", "(", "'-i'", ")", "if", "debug", ":", "p_args", ".", "extend", "(", "[", "'-m'", ",", "'pdb'", "]", ")", "if", "fname", "is", "not", "None", ":", "if", "os", ".", "name", "==", "'nt'", "and", "debug", ":", "# When calling pdb on Windows, one has to replace backslashes by\r", "# slashes to avoid confusion with escape characters (otherwise, \r", "# for example, '\\t' will be interpreted as a tabulation):\r", "p_args", ".", "append", "(", "osp", ".", "normpath", "(", "fname", ")", ".", "replace", "(", "os", ".", "sep", ",", "'/'", ")", ")", "else", ":", "p_args", ".", "append", "(", "fname", ")", "if", "end_args", ":", "p_args", ".", "extend", "(", "shell_split", "(", "end_args", ")", ")", "return", "p_args" ]

[ "Construct", "Python", "interpreter", "arguments" ]

[ "def", "html_to_fc", "(", "html", "=", "None", ",", "clean_html", "=", "None", ",", "clean_visible", "=", "None", ",", "encoding", "=", "None", ",", "url", "=", "None", ",", "timestamp", "=", "None", ",", "other_features", "=", "None", ")", ":", "def", "add_feature", "(", "name", ",", "xs", ")", ":", "if", "name", "not", "in", "fc", ":", "fc", "[", "name", "]", "=", "StringCounter", "(", ")", "fc", "[", "name", "]", "+=", "StringCounter", "(", "xs", ")", "timestamp", "=", "timestamp", "or", "int", "(", "time", ".", "time", "(", ")", "*", "1000", ")", "other_features", "=", "other_features", "or", "{", "}", "if", "clean_html", "is", "None", ":", "if", "html", "is", "not", "None", ":", "try", ":", "clean_html_utf8", "=", "make_clean_html", "(", "html", ",", "encoding", "=", "encoding", ")", "except", ":", "logger", ".", "warn", "(", "'dropping doc because:'", ",", "exc_info", "=", "True", ")", "return", "clean_html", "=", "clean_html_utf8", ".", "decode", "(", "'utf-8'", ")", "else", ":", "clean_html_utf8", "=", "u''", "clean_html", "=", "u''", "else", ":", "clean_html_utf8", "=", "u''", "if", "clean_visible", "is", "None", "or", "len", "(", "clean_visible", ")", "==", "0", ":", "clean_visible", "=", "make_clean_visible", "(", "clean_html_utf8", ")", ".", "decode", "(", "'utf-8'", ")", "elif", "isinstance", "(", "clean_visible", ",", "str", ")", ":", "clean_visible", "=", "clean_visible", ".", "decode", "(", "'utf-8'", ")", "fc", "=", "FeatureCollection", "(", ")", "fc", "[", "u'meta_raw'", "]", "=", "html", "and", "uni", "(", "html", ",", "encoding", ")", "or", "u''", "fc", "[", "u'meta_clean_html'", "]", "=", "clean_html", "fc", "[", "u'meta_clean_visible'", "]", "=", "clean_visible", "fc", "[", "u'meta_timestamp'", "]", "=", "unicode", "(", "timestamp", ")", "url", "=", "url", "or", "u''", "fc", "[", "u'meta_url'", "]", "=", "uni", "(", "url", ")", "add_feature", "(", "u'icq'", ",", "features", ".", "ICQs", "(", "clean_visible", ")", ")", "add_feature", "(", "u'skype'", ",", "features", ".", "skypes", "(", "clean_visible", ")", ")", "add_feature", "(", "u'phone'", ",", "features", ".", "phones", "(", "clean_visible", ")", ")", "add_feature", "(", "u'email'", ",", "features", ".", "emails", "(", "clean_visible", ")", ")", "bowNP", ",", "normalizations", "=", "features", ".", "noun_phrases", "(", "cleanse", "(", "clean_visible", ")", ",", "included_unnormalized", "=", "True", ")", "add_feature", "(", "u'bowNP'", ",", "bowNP", ")", "bowNP_unnorm", "=", "chain", "(", "*", "normalizations", ".", "values", "(", ")", ")", "add_feature", "(", "u'bowNP_unnorm'", ",", "bowNP_unnorm", ")", "add_feature", "(", "u'image_url'", ",", "features", ".", "image_urls", "(", "clean_html", ")", ")", "add_feature", "(", "u'a_url'", ",", "features", ".", "a_urls", "(", "clean_html", ")", ")", "## get parsed versions, extract usernames", "fc", "[", "u'img_url_path_dirs'", "]", "=", "features", ".", "path_dirs", "(", "fc", "[", "u'image_url'", "]", ")", "fc", "[", "u'img_url_hostnames'", "]", "=", "features", ".", "host_names", "(", "fc", "[", "u'image_url'", "]", ")", "fc", "[", "u'usernames'", "]", "=", "features", ".", "usernames", "(", "fc", "[", "u'image_url'", "]", ")", "fc", "[", "u'a_url_path_dirs'", "]", "=", "features", ".", "path_dirs", "(", "fc", "[", "u'a_url'", "]", ")", "fc", "[", "u'a_url_hostnames'", "]", "=", "features", ".", "host_names", "(", "fc", "[", "u'a_url'", "]", ")", "fc", "[", "u'usernames'", "]", "+=", "features", ".", "usernames", "(", "fc", "[", "u'a_url'", "]", ")", "#fc[u'usernames'] += features.usernames2(", "# fc[u'meta_clean_visible'])", "# beginning of treating this as a pipeline...", "xform", "=", "features", ".", "entity_names", "(", ")", "fc", "=", "xform", ".", "process", "(", "fc", ")", "for", "feat_name", ",", "feat_val", "in", "other_features", ".", "iteritems", "(", ")", ":", "fc", "[", "feat_name", "]", "+=", "StringCounter", "(", "feat_val", ")", "return", "fc" ]

[ "html", "is", "expected", "to", "be", "a", "raw", "string", "received", "over", "the", "wire", "from", "a", "remote", "webserver", "and", "encoding", "if", "provided", "is", "used", "to", "decode", "it", ".", "Typically", "encoding", "comes", "from", "the", "Content", "-", "Type", "header", "field", ".", "The", ":", "func", ":", "~streamcorpus_pipeline", ".", "_clean_html", ".", "make_clean_html", "function", "handles", "character", "encodings", "." ]

[ "def", "img_src", "(", "url", ",", "class_", "=", "\"\"", ",", "responsive", "=", "False", ",", "lazy_load", "=", "False", ",", "id_", "=", "\"\"", ")", ":", "if", "not", "url", ".", "startswith", "(", "\"http://\"", ")", "and", "not", "url", ".", "startswith", "(", "\"https://\"", ")", ":", "url", "=", "static_url", "(", "url", ")", "data_src", "=", "\"\"", "if", "responsive", ":", "class_", "+=", "\" responsive\"", "if", "lazy_load", ":", "data_src", "=", "url", "# 1x1 image", "url", "=", "\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mNgYAAAAAMAASsJTYQAAAAASUVORK5CYII=\"", "class_", "+=", "\" lazy\"", "img", "=", "\"<img src=\\\"{src}\\\" class=\\\"{class_}\\\" id=\\\"{id_}\\\" data-src={data_src}>\"", ".", "format", "(", "src", "=", "url", ",", "class_", "=", "class_", ",", "id_", "=", "id_", ",", "data_src", "=", "data_src", ")", "return", "Markup", "(", "img", ")" ]

[ "Create", "an", "image", "src" ]

[ "def", "get_offset", "(", "self", ",", "envelope", ")", ":", "if", "isinstance", "(", "envelope", ",", "collections", ".", "Sequence", ")", ":", "envelope", "=", "Envelope", "(", "envelope", ")", "if", "not", "(", "self", ".", "envelope", ".", "contains", "(", "envelope", ")", "or", "self", ".", "envelope", ".", "intersects", "(", "envelope", ")", ")", ":", "raise", "ValueError", "(", "'Envelope does not intersect with this extent'", ")", "coords", "=", "self", ".", "affine", ".", "transform", "(", "(", "envelope", ".", "ul", ",", "envelope", ".", "lr", ")", ")", "nxy", "=", "[", "(", "min", "(", "dest", ",", "size", ")", "-", "origin", ")", "or", "1", "for", "size", ",", "origin", ",", "dest", "in", "zip", "(", "self", ".", "size", ",", "*", "coords", ")", "]", "return", "coords", "[", "0", "]", "+", "tuple", "(", "nxy", ")" ]

[ "Returns", "a", "4", "-", "tuple", "pixel", "window", "(", "x_offset", "y_offset", "x_size", "y_size", ")", "." ]

[ "def", "show_completion_list", "(", "self", ",", "completions", ",", "completion_text", "=", "\"\"", ")", ":", "if", "not", "completions", ":", "return", "if", "not", "isinstance", "(", "completions", "[", "0", "]", ",", "tuple", ")", ":", "completions", "=", "[", "(", "c", ",", "''", ")", "for", "c", "in", "completions", "]", "if", "len", "(", "completions", ")", "==", "1", "and", "completions", "[", "0", "]", "[", "0", "]", "==", "completion_text", ":", "return", "self", ".", "completion_text", "=", "completion_text", "# Sorting completion list (entries starting with underscore are\r", "# put at the end of the list):\r", "underscore", "=", "set", "(", "[", "(", "comp", ",", "t", ")", "for", "(", "comp", ",", "t", ")", "in", "completions", "if", "comp", ".", "startswith", "(", "'_'", ")", "]", ")", "completions", "=", "sorted", "(", "set", "(", "completions", ")", "-", "underscore", ",", "key", "=", "lambda", "x", ":", "str_lower", "(", "x", "[", "0", "]", ")", ")", "completions", "+=", "sorted", "(", "underscore", ",", "key", "=", "lambda", "x", ":", "str_lower", "(", "x", "[", "0", "]", ")", ")", "self", ".", "show_completion_widget", "(", "completions", ")" ]

[ "Display", "the", "possible", "completions" ]

[ "def", "next", "(", "self", ")", ":", "# all agents acted, init next step", "t", "=", "time", ".", "time", "(", ")", "if", "len", "(", "self", ".", "_agents_to_act", ")", "==", "0", ":", "self", ".", "_init_step", "(", ")", "addr", "=", "self", ".", "_agents_to_act", ".", "pop", "(", "0", ")", "aiomas", ".", "run", "(", "until", "=", "self", ".", "env", ".", "trigger_act", "(", "addr", "=", "addr", ")", ")", "t2", "=", "time", ".", "time", "(", ")", "self", ".", "_step_processing_time", "+=", "t2", "-", "t", "# all agents acted, finalize current step", "if", "len", "(", "self", ".", "_agents_to_act", ")", "==", "0", ":", "self", ".", "_finalize_step", "(", ")" ]

[ "Trigger", "next", "agent", "to", ":", "py", ":", "meth", ":", "~creamas", ".", "core", ".", "CreativeAgent", ".", "act", "in", "the", "current", "step", "." ]

[ "def", "attach", "(", "self", ",", "attached_file", ",", "*", "*", "attrs", ")", ":", "return", "TaskAttachments", "(", "self", ".", "requester", ")", ".", "create", "(", "self", ".", "project", ",", "self", ".", "id", ",", "attached_file", ",", "*", "*", "attrs", ")" ]

[ "Attach", "a", "file", "to", "the", ":", "class", ":", "Task" ]

[ "def", "strip_doc_string", "(", "proto", ")", ":", "# type: (google.protobuf.message.Message) -> None", "assert", "isinstance", "(", "proto", ",", "google", ".", "protobuf", ".", "message", ".", "Message", ")", "for", "descriptor", "in", "proto", ".", "DESCRIPTOR", ".", "fields", ":", "if", "descriptor", ".", "name", "==", "'doc_string'", ":", "proto", ".", "ClearField", "(", "descriptor", ".", "name", ")", "elif", "descriptor", ".", "type", "==", "descriptor", ".", "TYPE_MESSAGE", ":", "if", "descriptor", ".", "label", "==", "descriptor", ".", "LABEL_REPEATED", ":", "for", "x", "in", "getattr", "(", "proto", ",", "descriptor", ".", "name", ")", ":", "strip_doc_string", "(", "x", ")", "elif", "proto", ".", "HasField", "(", "descriptor", ".", "name", ")", ":", "strip_doc_string", "(", "getattr", "(", "proto", ",", "descriptor", ".", "name", ")", ")" ]

[ "Empties", "doc_string", "field", "on", "any", "nested", "protobuf", "messages" ]

[ "def", "reorder_matrix", "(", "m1", ",", "cost", "=", "'line'", ",", "verbose", "=", "False", ",", "H", "=", "1e4", ",", "Texp", "=", "10", ",", "T0", "=", "1e-3", ",", "Hbrk", "=", "10", ")", ":", "from", "scipy", "import", "linalg", ",", "stats", "n", "=", "len", "(", "m1", ")", "if", "n", "<", "2", ":", "raise", "BCTParamError", "(", "\"align_matrix will infinite loop on a singleton \"", "\"or null matrix.\"", ")", "# generate cost function", "if", "cost", "==", "'line'", ":", "profile", "=", "stats", ".", "norm", ".", "pdf", "(", "range", "(", "1", ",", "n", "+", "1", ")", ",", "loc", "=", "0", ",", "scale", "=", "n", "/", "2", ")", "[", ":", ":", "-", "1", "]", "elif", "cost", "==", "'circ'", ":", "profile", "=", "stats", ".", "norm", ".", "pdf", "(", "range", "(", "1", ",", "n", "+", "1", ")", ",", "loc", "=", "n", "/", "2", ",", "scale", "=", "n", "/", "4", ")", "[", ":", ":", "-", "1", "]", "else", ":", "raise", "BCTParamError", "(", "'cost must be line or circ'", ")", "costf", "=", "linalg", ".", "toeplitz", "(", "profile", ",", "r", "=", "profile", ")", "*", "np", ".", "logical_not", "(", "np", ".", "eye", "(", "n", ")", ")", "costf", "/=", "np", ".", "sum", "(", "costf", ")", "# establish maxcost, lowcost, mincost", "maxcost", "=", "np", ".", "sum", "(", "np", ".", "sort", "(", "costf", ".", "flat", ")", "*", "np", ".", "sort", "(", "m1", ".", "flat", ")", ")", "lowcost", "=", "np", ".", "sum", "(", "m1", "*", "costf", ")", "/", "maxcost", "mincost", "=", "lowcost", "# initialize", "anew", "=", "np", ".", "arange", "(", "n", ")", "amin", "=", "np", ".", "arange", "(", "n", ")", "h", "=", "0", "hcnt", "=", "0", "# adjust annealing parameters", "# H determines the maximal number of steps (user specified)", "# Texp determines the steepness of the temperature gradient", "Texp", "=", "1", "-", "Texp", "/", "H", "# T0 sets the initial temperature and scales the energy term (user provided)", "# Hbrk sets a break point for the stimulation", "Hbrk", "=", "H", "/", "Hbrk", "while", "h", "<", "H", ":", "h", "+=", "1", "hcnt", "+=", "1", "# terminate if no new mincost has been found for some time", "if", "hcnt", ">", "Hbrk", ":", "break", "T", "=", "T0", "*", "Texp", "**", "h", "atmp", "=", "anew", ".", "copy", "(", ")", "r1", ",", "r2", "=", "rng", ".", "randint", "(", "n", ",", "size", "=", "(", "2", ",", ")", ")", "while", "r1", "==", "r2", ":", "r2", "=", "rng", ".", "randint", "(", "n", ")", "atmp", "[", "r1", "]", "=", "anew", "[", "r2", "]", "atmp", "[", "r2", "]", "=", "anew", "[", "r1", "]", "costnew", "=", "np", ".", "sum", "(", "(", "m1", "[", "np", ".", "ix_", "(", "atmp", ",", "atmp", ")", "]", ")", "*", "costf", ")", "/", "maxcost", "# annealing", "if", "costnew", "<", "lowcost", "or", "rng", ".", "random_sample", "(", ")", "<", "np", ".", "exp", "(", "-", "(", "costnew", "-", "lowcost", ")", "/", "T", ")", ":", "anew", "=", "atmp", "lowcost", "=", "costnew", "# is this a new absolute best?", "if", "lowcost", "<", "mincost", ":", "amin", "=", "anew", "mincost", "=", "lowcost", "if", "verbose", ":", "print", "(", "'step %i ... current lowest cost = %f'", "%", "(", "h", ",", "mincost", ")", ")", "hcnt", "=", "0", "if", "verbose", ":", "print", "(", "'step %i ... final lowest cost = %f'", "%", "(", "h", ",", "mincost", ")", ")", "M_reordered", "=", "m1", "[", "np", ".", "ix_", "(", "amin", ",", "amin", ")", "]", "M_indices", "=", "amin", "cost", "=", "mincost", "return", "M_reordered", ",", "M_indices", ",", "cost" ]

[ "This", "function", "rearranges", "the", "nodes", "in", "matrix", "M1", "such", "that", "the", "matrix", "elements", "are", "squeezed", "along", "the", "main", "diagonal", ".", "The", "function", "uses", "a", "version", "of", "simulated", "annealing", "." ]

[ "def", "database_exists", "(", "name", ",", "*", "*", "kwargs", ")", ":", "with", "settings", "(", "hide", "(", "'running'", ",", "'stdout'", ",", "'stderr'", ",", "'warnings'", ")", ",", "warn_only", "=", "True", ")", ":", "res", "=", "query", "(", "\"SHOW DATABASES LIKE '%(name)s';\"", "%", "{", "'name'", ":", "name", "}", ",", "*", "*", "kwargs", ")", "return", "res", ".", "succeeded", "and", "(", "res", "==", "name", ")" ]

[ "Check", "if", "a", "MySQL", "database", "exists", "." ]

[ "def", "get_current_branch", "(", "self", ",", "location", ")", ":", "# git-symbolic-ref exits with empty stdout if \"HEAD\" is a detached", "# HEAD rather than a symbolic ref. In addition, the -q causes the", "# command to exit with status code 1 instead of 128 in this case", "# and to suppress the message to stderr.", "args", "=", "[", "'symbolic-ref'", ",", "'-q'", ",", "'HEAD'", "]", "output", "=", "self", ".", "run_command", "(", "args", ",", "extra_ok_returncodes", "=", "(", "1", ",", ")", ",", "show_stdout", "=", "False", ",", "cwd", "=", "location", ",", ")", "ref", "=", "output", ".", "strip", "(", ")", "if", "ref", ".", "startswith", "(", "'refs/heads/'", ")", ":", "return", "ref", "[", "len", "(", "'refs/heads/'", ")", ":", "]", "return", "None" ]

[ "Return", "the", "current", "branch", "or", "None", "if", "HEAD", "isn", "t", "at", "a", "branch", "(", "e", ".", "g", ".", "detached", "HEAD", ")", "." ]

[ "def", "_ParseNamesString", "(", "self", ",", "names_string", ")", ":", "if", "not", "names_string", ":", "return", "names_string", "=", "names_string", ".", "lower", "(", ")", "names", "=", "[", "name", ".", "strip", "(", ")", "for", "name", "in", "names_string", ".", "split", "(", "','", ")", "]", "file_entry_filter", "=", "file_entry_filters", ".", "NamesFileEntryFilter", "(", "names", ")", "self", ".", "_filter_collection", ".", "AddFilter", "(", "file_entry_filter", ")" ]

[ "Parses", "the", "name", "string", "." ]

[ "def", "replace", "(", "pretty", ",", "old_str", ",", "new_str", ")", ":", "out_str", "=", "''", "line_number", "=", "1", "changes", "=", "0", "for", "line", "in", "pretty", ".", "splitlines", "(", "keepends", "=", "True", ")", ":", "new_line", "=", "line", ".", "replace", "(", "old_str", ",", "new_str", ")", "if", "line", ".", "find", "(", "old_str", ")", "!=", "-", "1", ":", "logging", ".", "debug", "(", "'%s'", ",", "line_number", ")", "logging", ".", "debug", "(", "'< %s'", ",", "line", ")", "logging", ".", "debug", "(", "'> %s'", ",", "new_line", ")", "changes", "+=", "1", "out_str", "+=", "new_line", "line_number", "+=", "1", "logging", ".", "info", "(", "'Total changes(%s): %s'", ",", "old_str", ",", "changes", ")", "return", "out_str" ]

[ "Replace", "strings", "giving", "some", "info", "on", "where", "the", "replacement", "was", "done" ]

[ "def", "AddPassword", "(", "self", ",", "fileset", ")", ":", "passwd", "=", "fileset", ".", "get", "(", "\"/etc/passwd\"", ")", "if", "passwd", ":", "self", ".", "_ParseFile", "(", "passwd", ",", "self", ".", "ParsePasswdEntry", ")", "else", ":", "logging", ".", "debug", "(", "\"No /etc/passwd file.\"", ")" ]

[ "Add", "the", "passwd", "entries", "to", "the", "shadow", "store", "." ]

[ "def", "associate_hosting_device_with_config_agent", "(", "self", ",", "client", ",", "config_agent_id", ",", "body", ")", ":", "return", "client", ".", "post", "(", "(", "ConfigAgentHandlingHostingDevice", ".", "resource_path", "+", "CFG_AGENT_HOSTING_DEVICES", ")", "%", "config_agent_id", ",", "body", "=", "body", ")" ]

[ "Associates", "a", "hosting_device", "with", "a", "config", "agent", "." ]

[ "def", "build", "(", "ctx", ",", "less", "=", "False", ",", "docs", "=", "False", ",", "js", "=", "False", ",", "force", "=", "False", ")", ":", "specified", "=", "any", "(", "[", "less", ",", "docs", ",", "js", "]", ")", "buildall", "=", "not", "specified", "if", "buildall", "or", "less", ":", "less_fname", "=", "ctx", ".", "pkg", ".", "source_less", "/", "ctx", ".", "pkg", ".", "name", "+", "'.less'", "if", "less_fname", ".", "exists", "(", ")", ":", "lessc", ".", "LessRule", "(", "ctx", ",", "src", "=", "'{pkg.source_less}/{pkg.name}.less'", ",", "dst", "=", "'{pkg.django_static}/{pkg.name}/css/{pkg.name}-{version}.min.css'", ",", "force", "=", "force", ")", "elif", "less", ":", "print", "(", "\"WARNING: build --less specified, but no file at:\"", ",", "less_fname", ")", "if", "buildall", "or", "docs", ":", "if", "WARN_ABOUT_SETTINGS", ":", "warnings", ".", "warn", "(", "\"autodoc might need a dummy settings file in the root of \"", "\"your package. Since it runs in a separate process you cannot\"", "\"use settings.configure()\"", ")", "doctools", ".", "build", "(", "ctx", ",", "force", "=", "force", ")", "if", "buildall", "or", "js", ":", "build_js", "(", "ctx", ",", "force", ")", "if", "HAVE_SETTINGS", "and", "(", "force", "or", "changed", "(", "ctx", ".", "pkg", ".", "django_static", ")", ")", ":", "collectstatic", "(", "ctx", ",", "DJANGO_SETTINGS_MODULE", ")" ]

[ "Build", "everything", "and", "collectstatic", "." ]

[ "async", "def", "sign", "(", "self", ",", "message", ":", "bytes", ",", "verkey", ":", "str", "=", "None", ")", "->", "bytes", ":", "LOGGER", ".", "debug", "(", "'Wallet.sign >>> message: %s, verkey: %s'", ",", "message", ",", "verkey", ")", "if", "not", "message", ":", "LOGGER", ".", "debug", "(", "'Wallet.sign <!< No message to sign'", ")", "raise", "AbsentMessage", "(", "'No message to sign'", ")", "if", "not", "self", ".", "handle", ":", "LOGGER", ".", "debug", "(", "'Wallet.sign <!< Wallet %s is closed'", ",", "self", ".", "name", ")", "raise", "WalletState", "(", "'Wallet {} is closed'", ".", "format", "(", "self", ".", "name", ")", ")", "rv", "=", "await", "crypto", ".", "crypto_sign", "(", "self", ".", "handle", ",", "verkey", "or", "self", ".", "verkey", ",", "message", ")", "LOGGER", ".", "debug", "(", "'Wallet.sign <<< %s'", ",", "rv", ")", "return", "rv" ]

[ "Derive", "signing", "key", "and", "Sign", "message", ";", "return", "signature", ".", "Raise", "WalletState", "if", "wallet", "is", "closed", ".", "Raise", "AbsentMessage", "for", "missing", "message", "or", "WalletState", "if", "wallet", "is", "closed", "." ]

[ "def", "open", "(", "self", ",", "vendor_id", ":", "int", "=", "0x16c0", ",", "product_id", ":", "int", "=", "0x5dc", ",", "bus", ":", "int", "=", "None", ",", "address", ":", "int", "=", "None", ")", "->", "bool", ":", "kwargs", "=", "{", "}", "if", "vendor_id", ":", "kwargs", "[", "\"idVendor\"", "]", "=", "vendor_id", "if", "product_id", ":", "kwargs", "[", "\"idProduct\"", "]", "=", "product_id", "if", "bus", ":", "kwargs", "[", "\"bus\"", "]", "=", "bus", "if", "address", ":", "kwargs", "[", "\"address\"", "]", "=", "address", "# Find the uDMX interface", "self", ".", "_dev", "=", "usb", ".", "core", ".", "find", "(", "*", "*", "kwargs", ")", "return", "self", ".", "_dev", "is", "not", "None" ]

[ "Open", "the", "first", "device", "that", "matches", "the", "search", "criteria", ".", "Th", "default", "parameters", "are", "set", "up", "for", "the", "likely", "most", "common", "case", "of", "a", "single", "uDMX", "interface", ".", "However", "for", "the", "case", "of", "multiple", "uDMX", "interfaces", "you", "can", "use", "the", "bus", "and", "address", "paramters", "to", "further", "specifiy", "the", "uDMX", "interface", "to", "be", "opened", ".", ":", "param", "vendor_id", ":", ":", "param", "product_id", ":", ":", "param", "bus", ":", "USB", "bus", "number", "1", "-", "n", ":", "param", "address", ":", "USB", "device", "address", "1", "-", "n", ":", "return", ":", "Returns", "true", "if", "a", "device", "was", "opened", ".", "Otherwise", "returns", "false", "." ]

[ "def", "get_dem_mosaic_cmd", "(", "fn_list", ",", "o", ",", "fn_list_txt", "=", "None", ",", "tr", "=", "None", ",", "t_srs", "=", "None", ",", "t_projwin", "=", "None", ",", "georef_tile_size", "=", "None", ",", "threads", "=", "None", ",", "tile", "=", "None", ",", "stat", "=", "None", ")", ":", "cmd", "=", "[", "'dem_mosaic'", ",", "]", "if", "o", "is", "None", ":", "o", "=", "'mos'", "cmd", ".", "extend", "(", "[", "'-o'", ",", "o", "]", ")", "if", "threads", "is", "None", ":", "from", "pygeotools", ".", "lib", "import", "iolib", "threads", "=", "iolib", ".", "cpu_count", "(", ")", "cmd", ".", "extend", "(", "[", "'--threads'", ",", "threads", "]", ")", "if", "tr", "is", "not", "None", ":", "cmd", ".", "extend", "(", "[", "'--tr'", ",", "tr", "]", ")", "if", "t_srs", "is", "not", "None", ":", "#cmd.extend(['--t_srs', t_srs.ExportToProj4()])", "cmd", ".", "extend", "(", "[", "'--t_srs'", ",", "'\"%s\"'", "%", "t_srs", ".", "ExportToProj4", "(", ")", "]", ")", "#cmd.extend(['--t_srs', \"%s\" % t_srs.ExportToProj4()])", "if", "t_projwin", "is", "not", "None", ":", "cmd", ".", "append", "(", "'--t_projwin'", ")", "cmd", ".", "extend", "(", "t_projwin", ")", "cmd", ".", "append", "(", "'--force-projwin'", ")", "if", "tile", "is", "not", "None", ":", "#Not yet implemented", "#cmd.extend(tile_list)", "cmd", ".", "append", "(", "'--tile-index'", ")", "cmd", ".", "append", "(", "tile", ")", "if", "georef_tile_size", "is", "not", "None", ":", "cmd", ".", "extend", "(", "[", "'--georef-tile-size'", ",", "georef_tile_size", "]", ")", "if", "stat", "is", "not", "None", ":", "if", "stat", "==", "'wmean'", ":", "stat", "=", "None", "else", ":", "cmd", ".", "append", "(", "'--%s'", "%", "stat", ".", "replace", "(", "'index'", ",", "''", ")", ")", "if", "stat", "in", "[", "'lastindex'", ",", "'firstindex'", ",", "'medianindex'", "]", ":", "#This will write out the index map to -last.tif by default", "cmd", ".", "append", "(", "'--save-index-map'", ")", "#Make sure we don't have ndv that conflicts with 0-based DEM indices", "cmd", ".", "extend", "(", "[", "'--output-nodata-value'", ",", "'-9999'", "]", ")", "#else:", "# cmd.extend(['--save-dem-weight', o+'_weight'])", "#If user provided a file containing list of DEMs to mosaic (useful to avoid long bash command issues)", "if", "fn_list_txt", "is", "not", "None", ":", "if", "os", ".", "path", ".", "exists", "(", "fn_list_txt", ")", ":", "cmd", ".", "append", "(", "'-l'", ")", "cmd", ".", "append", "(", "fn_list_txt", ")", "else", ":", "print", "(", "\"Could not find input text file containing list of inputs\"", ")", "else", ":", "cmd", ".", "extend", "(", "fn_list", ")", "cmd", "=", "[", "str", "(", "i", ")", "for", "i", "in", "cmd", "]", "#print(cmd)", "#return subprocess.call(cmd)", "return", "cmd" ]

[ "Create", "ASP", "dem_mosaic", "command", "Useful", "for", "spawning", "many", "single", "-", "threaded", "mosaicing", "processes" ]

[ "def", "_fit_orbit_mlogl", "(", "new_vxvv", ",", "vxvv", ",", "vxvv_err", ",", "pot", ",", "radec", ",", "lb", ",", "customsky", ",", "lb_to_customsky", ",", "pmllpmbb_to_customsky", ",", "tmockAA", ",", "ro", ",", "vo", ",", "obs", ")", ":", "#Use this _parse_args routine, which does forward and backward integration", "iR", ",", "ivR", ",", "ivT", ",", "iz", ",", "ivz", ",", "iphi", "=", "tmockAA", ".", "_parse_args", "(", "True", ",", "False", ",", "new_vxvv", "[", "0", "]", ",", "new_vxvv", "[", "1", "]", ",", "new_vxvv", "[", "2", "]", ",", "new_vxvv", "[", "3", "]", ",", "new_vxvv", "[", "4", "]", ",", "new_vxvv", "[", "5", "]", ")", "if", "radec", "or", "lb", "or", "customsky", ":", "#Need to transform to (l,b), (ra,dec), or a custom set", "#First transform to X,Y,Z,vX,vY,vZ (Galactic)", "X", ",", "Y", ",", "Z", "=", "coords", ".", "galcencyl_to_XYZ", "(", "iR", ".", "flatten", "(", ")", ",", "iphi", ".", "flatten", "(", ")", ",", "iz", ".", "flatten", "(", ")", ",", "Xsun", "=", "obs", "[", "0", "]", "/", "ro", ",", "Zsun", "=", "obs", "[", "2", "]", "/", "ro", ")", ".", "T", "vX", ",", "vY", ",", "vZ", "=", "coords", ".", "galcencyl_to_vxvyvz", "(", "ivR", ".", "flatten", "(", ")", ",", "ivT", ".", "flatten", "(", ")", ",", "ivz", ".", "flatten", "(", ")", ",", "iphi", ".", "flatten", "(", ")", ",", "vsun", "=", "nu", ".", "array", "(", "obs", "[", "3", ":", "6", "]", ")", "/", "vo", ",", "Xsun", "=", "obs", "[", "0", "]", "/", "ro", ",", "Zsun", "=", "obs", "[", "2", "]", "/", "ro", ")", ".", "T", "bad_indx", "=", "(", "X", "==", "0.", ")", "*", "(", "Y", "==", "0.", ")", "*", "(", "Z", "==", "0.", ")", "if", "True", "in", "bad_indx", ":", "X", "[", "bad_indx", "]", "+=", "ro", "/", "10000.", "lbdvrpmllpmbb", "=", "coords", ".", "rectgal_to_sphergal", "(", "X", "*", "ro", ",", "Y", "*", "ro", ",", "Z", "*", "ro", ",", "vX", "*", "vo", ",", "vY", "*", "vo", ",", "vZ", "*", "vo", ",", "degree", "=", "True", ")", "if", "lb", ":", "orb_vxvv", "=", "nu", ".", "array", "(", "[", "lbdvrpmllpmbb", "[", ":", ",", "0", "]", ",", "lbdvrpmllpmbb", "[", ":", ",", "1", "]", ",", "lbdvrpmllpmbb", "[", ":", ",", "2", "]", ",", "lbdvrpmllpmbb", "[", ":", ",", "4", "]", ",", "lbdvrpmllpmbb", "[", ":", ",", "5", "]", ",", "lbdvrpmllpmbb", "[", ":", ",", "3", "]", "]", ")", ".", "T", "elif", "radec", ":", "#Further transform to ra,dec,pmra,pmdec", "radec", "=", "coords", ".", "lb_to_radec", "(", "lbdvrpmllpmbb", "[", ":", ",", "0", "]", ",", "lbdvrpmllpmbb", "[", ":", ",", "1", "]", ",", "degree", "=", "True", ",", "epoch", "=", "None", ")", "pmrapmdec", "=", "coords", ".", "pmllpmbb_to_pmrapmdec", "(", "lbdvrpmllpmbb", "[", ":", ",", "4", "]", ",", "lbdvrpmllpmbb", "[", ":", ",", "5", "]", ",", "lbdvrpmllpmbb", "[", ":", ",", "0", "]", ",", "lbdvrpmllpmbb", "[", ":", ",", "1", "]", ",", "degree", "=", "True", ",", "epoch", "=", "None", ")", "orb_vxvv", "=", "nu", ".", "array", "(", "[", "radec", "[", ":", ",", "0", "]", ",", "radec", "[", ":", ",", "1", "]", ",", "lbdvrpmllpmbb", "[", ":", ",", "2", "]", ",", "pmrapmdec", "[", ":", ",", "0", "]", ",", "pmrapmdec", "[", ":", ",", "1", "]", ",", "lbdvrpmllpmbb", "[", ":", ",", "3", "]", "]", ")", ".", "T", "elif", "customsky", ":", "#Further transform to ra,dec,pmra,pmdec", "customradec", "=", "lb_to_customsky", "(", "lbdvrpmllpmbb", "[", ":", ",", "0", "]", ",", "lbdvrpmllpmbb", "[", ":", ",", "1", "]", ",", "degree", "=", "True", ")", "custompmrapmdec", "=", "pmllpmbb_to_customsky", "(", "lbdvrpmllpmbb", "[", ":", ",", "4", "]", ",", "lbdvrpmllpmbb", "[", ":", ",", "5", "]", ",", "lbdvrpmllpmbb", "[", ":", ",", "0", "]", ",", "lbdvrpmllpmbb", "[", ":", ",", "1", "]", ",", "degree", "=", "True", ")", "orb_vxvv", "=", "nu", ".", "array", "(", "[", "customradec", "[", ":", ",", "0", "]", ",", "customradec", "[", ":", ",", "1", "]", ",", "lbdvrpmllpmbb", "[", ":", ",", "2", "]", ",", "custompmrapmdec", "[", ":", ",", "0", "]", ",", "custompmrapmdec", "[", ":", ",", "1", "]", ",", "lbdvrpmllpmbb", "[", ":", ",", "3", "]", "]", ")", ".", "T", "else", ":", "#shape=(2tintJ-1,6)", "orb_vxvv", "=", "nu", ".", "array", "(", "[", "iR", ".", "flatten", "(", ")", ",", "ivR", ".", "flatten", "(", ")", ",", "ivT", ".", "flatten", "(", ")", ",", "iz", ".", "flatten", "(", ")", ",", "ivz", ".", "flatten", "(", ")", ",", "iphi", ".", "flatten", "(", ")", "]", ")", ".", "T", "out", "=", "0.", "for", "ii", "in", "range", "(", "vxvv", ".", "shape", "[", "0", "]", ")", ":", "sub_vxvv", "=", "(", "orb_vxvv", "-", "vxvv", "[", "ii", ",", ":", "]", ".", "flatten", "(", ")", ")", "**", "2.", "#print(sub_vxvv[nu.argmin(nu.sum(sub_vxvv,axis=1))])", "if", "not", "vxvv_err", "is", "None", ":", "sub_vxvv", "/=", "vxvv_err", "[", "ii", ",", ":", "]", "**", "2.", "else", ":", "sub_vxvv", "/=", "0.01", "**", "2.", "out", "+=", "logsumexp", "(", "-", "0.5", "*", "nu", ".", "sum", "(", "sub_vxvv", ",", "axis", "=", "1", ")", ")", "return", "-", "out" ]

[ "The", "log", "likelihood", "for", "fitting", "an", "orbit" ]

[ "def", "qrot", "(", "vector", ",", "quaternion", ")", ":", "t", "=", "2", "*", "np", ".", "cross", "(", "quaternion", "[", "1", ":", "]", ",", "vector", ")", "v_rot", "=", "vector", "+", "quaternion", "[", "0", "]", "*", "t", "+", "np", ".", "cross", "(", "quaternion", "[", "1", ":", "]", ",", "t", ")", "return", "v_rot" ]

[ "Rotate", "a", "3D", "vector", "using", "quaternion", "algebra", "." ]

[ "def", "make_limited_stream", "(", "stream", ",", "limit", ")", ":", "if", "not", "isinstance", "(", "stream", ",", "LimitedStream", ")", ":", "if", "limit", "is", "None", ":", "raise", "TypeError", "(", "'stream not limited and no limit provided.'", ")", "stream", "=", "LimitedStream", "(", "stream", ",", "limit", ")", "return", "stream" ]

[ "Makes", "a", "stream", "limited", "." ]

[ "def", "sid_day_index", "(", "self", ",", "sid", ",", "day", ")", ":", "try", ":", "day_loc", "=", "self", ".", "sessions", ".", "get_loc", "(", "day", ")", "except", "Exception", ":", "raise", "NoDataOnDate", "(", "\"day={0} is outside of calendar={1}\"", ".", "format", "(", "day", ",", "self", ".", "sessions", ")", ")", "offset", "=", "day_loc", "-", "self", ".", "_calendar_offsets", "[", "sid", "]", "if", "offset", "<", "0", ":", "raise", "NoDataBeforeDate", "(", "\"No data on or before day={0} for sid={1}\"", ".", "format", "(", "day", ",", "sid", ")", ")", "ix", "=", "self", ".", "_first_rows", "[", "sid", "]", "+", "offset", "if", "ix", ">", "self", ".", "_last_rows", "[", "sid", "]", ":", "raise", "NoDataAfterDate", "(", "\"No data on or after day={0} for sid={1}\"", ".", "format", "(", "day", ",", "sid", ")", ")", "return", "ix" ]

[ "Parameters", "----------", "sid", ":", "int", "The", "asset", "identifier", ".", "day", ":", "datetime64", "-", "like", "Midnight", "of", "the", "day", "for", "which", "data", "is", "requested", "." ]

[ "def", "_query", "(", "action", "=", "None", ",", "command", "=", "None", ",", "args", "=", "None", ",", "method", "=", "'GET'", ",", "data", "=", "None", ")", ":", "subdomain", "=", "__opts__", ".", "get", "(", "'bamboohr'", ",", "{", "}", ")", ".", "get", "(", "'subdomain'", ",", "None", ")", "path", "=", "'https://api.bamboohr.com/api/gateway.php/{0}/v1/'", ".", "format", "(", "subdomain", ")", "if", "action", ":", "path", "+=", "action", "if", "command", ":", "path", "+=", "'/{0}'", ".", "format", "(", "command", ")", "log", ".", "debug", "(", "'BambooHR URL: %s'", ",", "path", ")", "if", "not", "isinstance", "(", "args", ",", "dict", ")", ":", "args", "=", "{", "}", "return_content", "=", "None", "result", "=", "salt", ".", "utils", ".", "http", ".", "query", "(", "path", ",", "method", ",", "username", "=", "_apikey", "(", ")", ",", "password", "=", "'saltypork'", ",", "params", "=", "args", ",", "data", "=", "data", ",", "decode", "=", "False", ",", "text", "=", "True", ",", "status", "=", "True", ",", "opts", "=", "__opts__", ",", ")", "log", ".", "debug", "(", "'BambooHR Response Status Code: %s'", ",", "result", "[", "'status'", "]", ")", "return", "[", "result", "[", "'status'", "]", ",", "result", "[", "'text'", "]", "]" ]

[ "Make", "a", "web", "call", "to", "BambooHR" ]

[ "def", "run_module_async", "(", "kwargs", ",", "job_id", ",", "timeout_secs", ",", "started_sender", ",", "econtext", ")", ":", "arunner", "=", "AsyncRunner", "(", "job_id", ",", "timeout_secs", ",", "started_sender", ",", "econtext", ",", "kwargs", ")", "arunner", ".", "run", "(", ")" ]

[ "Execute", "a", "module", "with", "its", "run", "status", "and", "result", "written", "to", "a", "file", "terminating", "on", "the", "process", "on", "completion", ".", "This", "function", "must", "run", "in", "a", "child", "forked", "using", ":", "func", ":", "create_fork_child", "." ]

[ "def", "prep_trans_tar", "(", "file_client", ",", "chunks", ",", "file_refs", ",", "pillar", "=", "None", ",", "id_", "=", "None", ",", "roster_grains", "=", "None", ")", ":", "gendir", "=", "tempfile", ".", "mkdtemp", "(", ")", "trans_tar", "=", "salt", ".", "utils", ".", "files", ".", "mkstemp", "(", ")", "lowfn", "=", "os", ".", "path", ".", "join", "(", "gendir", ",", "'lowstate.json'", ")", "pillarfn", "=", "os", ".", "path", ".", "join", "(", "gendir", ",", "'pillar.json'", ")", "roster_grainsfn", "=", "os", ".", "path", ".", "join", "(", "gendir", ",", "'roster_grains.json'", ")", "sync_refs", "=", "[", "[", "salt", ".", "utils", ".", "url", ".", "create", "(", "'_modules'", ")", "]", ",", "[", "salt", ".", "utils", ".", "url", ".", "create", "(", "'_states'", ")", "]", ",", "[", "salt", ".", "utils", ".", "url", ".", "create", "(", "'_grains'", ")", "]", ",", "[", "salt", ".", "utils", ".", "url", ".", "create", "(", "'_renderers'", ")", "]", ",", "[", "salt", ".", "utils", ".", "url", ".", "create", "(", "'_returners'", ")", "]", ",", "[", "salt", ".", "utils", ".", "url", ".", "create", "(", "'_output'", ")", "]", ",", "[", "salt", ".", "utils", ".", "url", ".", "create", "(", "'_utils'", ")", "]", ",", "]", "with", "salt", ".", "utils", ".", "files", ".", "fopen", "(", "lowfn", ",", "'w+'", ")", "as", "fp_", ":", "salt", ".", "utils", ".", "json", ".", "dump", "(", "chunks", ",", "fp_", ")", "if", "pillar", ":", "with", "salt", ".", "utils", ".", "files", ".", "fopen", "(", "pillarfn", ",", "'w+'", ")", "as", "fp_", ":", "salt", ".", "utils", ".", "json", ".", "dump", "(", "pillar", ",", "fp_", ")", "if", "roster_grains", ":", "with", "salt", ".", "utils", ".", "files", ".", "fopen", "(", "roster_grainsfn", ",", "'w+'", ")", "as", "fp_", ":", "salt", ".", "utils", ".", "json", ".", "dump", "(", "roster_grains", ",", "fp_", ")", "if", "id_", "is", "None", ":", "id_", "=", "''", "try", ":", "cachedir", "=", "os", ".", "path", ".", "join", "(", "'salt-ssh'", ",", "id_", ")", ".", "rstrip", "(", "os", ".", "sep", ")", "except", "AttributeError", ":", "# Minion ID should always be a str, but don't let an int break this", "cachedir", "=", "os", ".", "path", ".", "join", "(", "'salt-ssh'", ",", "six", ".", "text_type", "(", "id_", ")", ")", ".", "rstrip", "(", "os", ".", "sep", ")", "for", "saltenv", "in", "file_refs", ":", "# Location where files in this saltenv will be cached", "cache_dest_root", "=", "os", ".", "path", ".", "join", "(", "cachedir", ",", "'files'", ",", "saltenv", ")", "file_refs", "[", "saltenv", "]", ".", "extend", "(", "sync_refs", ")", "env_root", "=", "os", ".", "path", ".", "join", "(", "gendir", ",", "saltenv", ")", "if", "not", "os", ".", "path", ".", "isdir", "(", "env_root", ")", ":", "os", ".", "makedirs", "(", "env_root", ")", "for", "ref", "in", "file_refs", "[", "saltenv", "]", ":", "for", "name", "in", "ref", ":", "short", "=", "salt", ".", "utils", ".", "url", ".", "parse", "(", "name", ")", "[", "0", "]", ".", "lstrip", "(", "'/'", ")", "cache_dest", "=", "os", ".", "path", ".", "join", "(", "cache_dest_root", ",", "short", ")", "try", ":", "path", "=", "file_client", ".", "cache_file", "(", "name", ",", "saltenv", ",", "cachedir", "=", "cachedir", ")", "except", "IOError", ":", "path", "=", "''", "if", "path", ":", "tgt", "=", "os", ".", "path", ".", "join", "(", "env_root", ",", "short", ")", "tgt_dir", "=", "os", ".", "path", ".", "dirname", "(", "tgt", ")", "if", "not", "os", ".", "path", ".", "isdir", "(", "tgt_dir", ")", ":", "os", ".", "makedirs", "(", "tgt_dir", ")", "shutil", ".", "copy", "(", "path", ",", "tgt", ")", "continue", "try", ":", "files", "=", "file_client", ".", "cache_dir", "(", "name", ",", "saltenv", ",", "cachedir", "=", "cachedir", ")", "except", "IOError", ":", "files", "=", "''", "if", "files", ":", "for", "filename", "in", "files", ":", "fn", "=", "filename", "[", "len", "(", "file_client", ".", "get_cachedir", "(", "cache_dest", ")", ")", ":", "]", ".", "strip", "(", "'/'", ")", "tgt", "=", "os", ".", "path", ".", "join", "(", "env_root", ",", "short", ",", "fn", ",", ")", "tgt_dir", "=", "os", ".", "path", ".", "dirname", "(", "tgt", ")", "if", "not", "os", ".", "path", ".", "isdir", "(", "tgt_dir", ")", ":", "os", ".", "makedirs", "(", "tgt_dir", ")", "shutil", ".", "copy", "(", "filename", ",", "tgt", ")", "continue", "try", ":", "# cwd may not exist if it was removed but salt was run from it", "cwd", "=", "os", ".", "getcwd", "(", ")", "except", "OSError", ":", "cwd", "=", "None", "os", ".", "chdir", "(", "gendir", ")", "with", "closing", "(", "tarfile", ".", "open", "(", "trans_tar", ",", "'w:gz'", ")", ")", "as", "tfp", ":", "for", "root", ",", "dirs", ",", "files", "in", "salt", ".", "utils", ".", "path", ".", "os_walk", "(", "gendir", ")", ":", "for", "name", "in", "files", ":", "full", "=", "os", ".", "path", ".", "join", "(", "root", ",", "name", ")", "tfp", ".", "add", "(", "full", "[", "len", "(", "gendir", ")", ":", "]", ".", "lstrip", "(", "os", ".", "sep", ")", ")", "if", "cwd", ":", "os", ".", "chdir", "(", "cwd", ")", "shutil", ".", "rmtree", "(", "gendir", ")", "return", "trans_tar" ]

[ "Generate", "the", "execution", "package", "from", "the", "saltenv", "file", "refs", "and", "a", "low", "state", "data", "structure" ]

[ "def", "get_boundary_coords", "(", "x", ",", "y", ",", "spatial_pad", "=", "0", ")", ":", "west", "=", "np", ".", "min", "(", "x", ")", "-", "spatial_pad", "east", "=", "np", ".", "max", "(", "x", ")", "+", "spatial_pad", "north", "=", "np", ".", "max", "(", "y", ")", "+", "spatial_pad", "south", "=", "np", ".", "min", "(", "y", ")", "-", "spatial_pad", "return", "{", "'west'", ":", "west", ",", "'south'", ":", "south", ",", "'east'", ":", "east", ",", "'north'", ":", "north", "}" ]

[ "r", "Return", "bounding", "box", "based", "on", "given", "x", "and", "y", "coordinates", "assuming", "northern", "hemisphere", "." ]

[ "def", "street_name", "(", "self", ")", ":", "pattern", "=", "self", ".", "random_element", "(", "self", ".", "street_name_formats", ")", "return", "self", ".", "generator", ".", "parse", "(", "pattern", ")" ]

[ ":", "example", "Crist", "Parks" ]

[ "def", "from_file", "(", "cls", ",", "filename", ",", "beam", "=", "None", ")", ":", "header", "=", "fits", ".", "getheader", "(", "filename", ")", "return", "cls", ".", "from_header", "(", "header", ",", "beam", ")" ]

[ "Create", "a", "new", "WCSHelper", "class", "from", "a", "given", "fits", "file", "." ]

[ "def", "generate_samples", "(", "self", ")", ":", "filenames", "=", "glob_all", "(", "self", ".", "args", ".", "random_data_folder", ",", "'*.wav'", ")", "shuffle", "(", "filenames", ")", "while", "True", ":", "for", "fn", "in", "filenames", ":", "for", "x", ",", "y", "in", "self", ".", "vectors_from_fn", "(", "fn", ")", ":", "yield", "x", ",", "y" ]

[ "Generate", "training", "samples", "(", "network", "inputs", "and", "outputs", ")" ]

[ "def", "random_partition", "(", "n", ",", "n_data", ")", ":", "all_idxs", "=", "np", ".", "arange", "(", "n_data", ")", "np", ".", "random", ".", "shuffle", "(", "all_idxs", ")", "idxs1", "=", "all_idxs", "[", ":", "n", "]", "idxs2", "=", "all_idxs", "[", "n", ":", "]", "return", "idxs1", ",", "idxs2" ]

[ "return", "n", "random", "rows", "of", "data", "(", "and", "also", "the", "other", "len", "(", "data", ")", "-", "n", "rows", ")" ]

[ "def", "minify", "(", "drop_semi", "=", "True", ")", ":", "layout_handlers", "=", "{", "OpenBlock", ":", "layout_handler_openbrace", ",", "CloseBlock", ":", "layout_handler_closebrace", ",", "EndStatement", ":", "layout_handler_semicolon", ",", "Space", ":", "layout_handler_space_minimum", ",", "OptionalSpace", ":", "layout_handler_space_minimum", ",", "RequiredSpace", ":", "layout_handler_space_imply", ",", "(", "Space", ",", "OpenBlock", ")", ":", "layout_handler_openbrace", ",", "(", "Space", ",", "EndStatement", ")", ":", "layout_handler_semicolon", ",", "(", "OptionalSpace", ",", "EndStatement", ")", ":", "layout_handler_semicolon", ",", "}", "if", "drop_semi", ":", "# if these are defined, they should be dropped; should really", "# provide these as a flag.", "# layout_handlers.update({", "# OptionalNewline: None,", "# Dedent: None,", "# })", "layout_handlers", ".", "update", "(", "{", "EndStatement", ":", "layout_handler_semicolon_optional", ",", "# these two rules rely on the normalized resolution", "(", "OptionalSpace", ",", "EndStatement", ")", ":", "layout_handler_semicolon_optional", ",", "(", "EndStatement", ",", "CloseBlock", ")", ":", "layout_handler_closebrace", ",", "# this is a fallback rule for when Dedent is defined by", "# some other rule, which won't neuter all optional", "# semicolons.", "(", "EndStatement", ",", "Dedent", ")", ":", "rule_handler_noop", ",", "(", "(", "OptionalSpace", ",", "EndStatement", ")", ",", "CloseBlock", ")", ":", "layout_handler_closebrace", ",", "}", ")", "def", "minify_rule", "(", ")", ":", "return", "{", "'layout_handlers'", ":", "layout_handlers", ",", "'deferrable_handlers'", ":", "{", "Literal", ":", "deferrable_handler_literal_continuation", ",", "}", ",", "}", "return", "minify_rule" ]

[ "Rules", "for", "minifying", "output", "." ]

[ "def", "get_bbox", "(", "self", ",", "primitive", ")", ":", "accessor", "=", "primitive", ".", "attributes", ".", "get", "(", "'POSITION'", ")", "return", "accessor", ".", "min", ",", "accessor", ".", "max" ]

[ "Get", "the", "bounding", "box", "for", "the", "mesh" ]

[ "def", "_pool_put", "(", "pool_semaphore", ",", "tasks", ",", "put_to_pool_in", ",", "pool_size", ",", "id_self", ",", "is_stopping", ")", ":", "log", ".", "debug", "(", "'NuMap(%s) started pool_putter.'", "%", "id_self", ")", "last_tasks", "=", "{", "}", "for", "task", "in", "xrange", "(", "tasks", ".", "lenght", ")", ":", "last_tasks", "[", "task", "]", "=", "-", "1", "stop_tasks", "=", "[", "]", "while", "True", ":", "# are we stopping the Weaver?", "if", "is_stopping", "(", ")", ":", "log", ".", "debug", "(", "'NuMap(%s) pool_putter has been told to stop.'", "%", "id_self", ")", "tasks", ".", "stop", "(", ")", "# try to get a task", "try", ":", "log", ".", "debug", "(", "'NuMap(%s) pool_putter waits for next task.'", "%", "id_self", ")", "task", "=", "tasks", ".", "next", "(", ")", "log", ".", "debug", "(", "'NuMap(%s) pool_putter received next task.'", "%", "id_self", ")", "except", "StopIteration", ":", "# Weaver raised a StopIteration", "stop_task", "=", "tasks", ".", "i", "# current task", "log", ".", "debug", "(", "'NuMap(%s) pool_putter caught StopIteration from task %s.'", "%", "(", "id_self", ",", "stop_task", ")", ")", "if", "stop_task", "not", "in", "stop_tasks", ":", "# task raised stop for the first time.", "log", ".", "debug", "(", "'NuMap(%s) pool_putter task %s first-time finished.'", "%", "(", "id_self", ",", "stop_task", ")", ")", "stop_tasks", ".", "append", "(", "stop_task", ")", "pool_semaphore", ".", "acquire", "(", ")", "log", ".", "debug", "(", "'NuMap(%s) pool_putter sends a sentinel for task %s.'", "%", "(", "id_self", ",", "stop_task", ")", ")", "put_to_pool_in", "(", "(", "stop_task", ",", "None", ",", "last_tasks", "[", "stop_task", "]", ")", ")", "if", "len", "(", "stop_tasks", ")", "==", "tasks", ".", "lenght", ":", "log", ".", "debug", "(", "'NuMap(%s) pool_putter sent sentinels for all tasks.'", "%", "id_self", ")", "# all tasks have been stopped", "for", "_worker", "in", "xrange", "(", "pool_size", ")", ":", "put_to_pool_in", "(", "None", ")", "log", ".", "debug", "(", "'NuMap(%s) pool_putter sent sentinel for %s workers'", "%", "(", "id_self", ",", "pool_size", ")", ")", "# this kills the pool_putter", "break", "# multiple StopIterations for a tasks are ignored. ", "# This is for stride.", "continue", "# got task", "last_tasks", "[", "tasks", ".", "i", "]", "=", "task", "[", "-", "1", "]", "[", "0", "]", "# last valid result", "log", ".", "debug", "(", "'NuMap(%s) pool_putter waits for semaphore for task %s'", "%", "(", "id_self", ",", "task", ")", ")", "pool_semaphore", ".", "acquire", "(", ")", "log", ".", "debug", "(", "'NuMap(%s) pool_putter gets semaphore for task %s'", "%", "(", "id_self", ",", "task", ")", ")", "#gc.disable()", "put_to_pool_in", "(", "task", ")", "#gc.enable()", "log", ".", "debug", "(", "'NuMap(%s) pool_putter submits task %s to worker.'", "%", "(", "id_self", ",", "task", ")", ")", "log", ".", "debug", "(", "'NuMap(%s) pool_putter returns'", "%", "id_self", ")" ]

[ "(", "internal", ")", "Intended", "to", "be", "run", "in", "a", "seperate", "thread", ".", "Feeds", "tasks", "into", "to", "the", "pool", "whenever", "semaphore", "permits", ".", "Finishes", "if", "self", ".", "_stopping", "is", "set", "." ]

[ "def", "read_data_event", "(", "self", ",", "whence", ",", "complete", "=", "False", ",", "can_flush", "=", "False", ")", ":", "return", "Transition", "(", "None", ",", "_read_data_handler", "(", "whence", ",", "self", ",", "complete", ",", "can_flush", ")", ")" ]

[ "Creates", "a", "transition", "to", "a", "co", "-", "routine", "for", "retrieving", "data", "as", "bytes", "." ]

[ "def", "_get_common_url_parameters", "(", "request", ")", ":", "params", "=", "{", "'SERVICE'", ":", "request", ".", "service_type", ".", "value", "}", "if", "hasattr", "(", "request", ",", "'maxcc'", ")", ":", "params", "[", "'MAXCC'", "]", "=", "100.0", "*", "request", ".", "maxcc", "if", "hasattr", "(", "request", ",", "'custom_url_params'", ")", "and", "request", ".", "custom_url_params", "is", "not", "None", ":", "params", "=", "{", "*", "*", "params", ",", "*", "*", "{", "k", ".", "value", ":", "str", "(", "v", ")", "for", "k", ",", "v", "in", "request", ".", "custom_url_params", ".", "items", "(", ")", "}", "}", "if", "CustomUrlParam", ".", "EVALSCRIPT", ".", "value", "in", "params", ":", "evalscript", "=", "params", "[", "CustomUrlParam", ".", "EVALSCRIPT", ".", "value", "]", "params", "[", "CustomUrlParam", ".", "EVALSCRIPT", ".", "value", "]", "=", "b64encode", "(", "evalscript", ".", "encode", "(", ")", ")", ".", "decode", "(", ")", "if", "CustomUrlParam", ".", "GEOMETRY", ".", "value", "in", "params", ":", "geometry", "=", "params", "[", "CustomUrlParam", ".", "GEOMETRY", ".", "value", "]", "crs", "=", "request", ".", "bbox", ".", "crs", "if", "isinstance", "(", "geometry", ",", "Geometry", ")", ":", "if", "geometry", ".", "crs", "is", "not", "crs", ":", "raise", "ValueError", "(", "'Geometry object in custom_url_params should have the same CRS as given BBox'", ")", "else", ":", "geometry", "=", "Geometry", "(", "geometry", ",", "crs", ")", "if", "geometry", ".", "crs", "is", "CRS", ".", "WGS84", ":", "geometry", "=", "geometry", ".", "reverse", "(", ")", "params", "[", "CustomUrlParam", ".", "GEOMETRY", ".", "value", "]", "=", "geometry", ".", "wkt", "return", "params" ]

[ "Returns", "parameters", "common", "dictionary", "for", "WMS", "WCS", "and", "FIS", "request", "." ]

[ "def", "handle_stop_scan_command", "(", "self", ",", "scan_et", ")", ":", "scan_id", "=", "scan_et", ".", "attrib", ".", "get", "(", "'scan_id'", ")", "if", "scan_id", "is", "None", "or", "scan_id", "==", "''", ":", "raise", "OSPDError", "(", "'No scan_id attribute'", ",", "'stop_scan'", ")", "self", ".", "stop_scan", "(", "scan_id", ")", "return", "simple_response_str", "(", "'stop_scan'", ",", "200", ",", "'OK'", ")" ]

[ "Handles", "<stop_scan", ">", "command", "." ]

[ "def", "add", "(", "self", ",", "auth", ",", "method", ",", "args", ",", "notimeout", "=", "False", ")", ":", "authstr", "=", "self", ".", "_authstr", "(", "auth", ")", "self", ".", "_requests", ".", "setdefault", "(", "authstr", ",", "[", "]", ")", ".", "append", "(", "(", "method", ",", "args", ")", ")", "self", ".", "_notimeouts", ".", "setdefault", "(", "authstr", ",", "False", ")", "if", "notimeout", ":", "self", ".", "_notimeouts", "[", "authstr", "]", "=", "notimeout" ]

[ "Append", "a", "deferred", "request", "for", "a", "particular", "auth", "/", "CIK", "." ]

[ "def", "get_multi_causal_downstream", "(", "graph", ",", "nbunch", ":", "Union", "[", "BaseEntity", ",", "Iterable", "[", "BaseEntity", "]", "]", ")", ":", "result", "=", "get_downstream_causal_subgraph", "(", "graph", ",", "nbunch", ")", "expand_downstream_causal", "(", "graph", ",", "result", ")", "return", "result" ]

[ "Get", "the", "union", "of", "all", "of", "the", "2", "-", "level", "deep", "causal", "downstream", "subgraphs", "from", "the", "nbunch", "." ]

[ "def", "_load_properties", "(", "self", ",", "raw_bytes", ")", ":", "r", "=", "AMQPReader", "(", "raw_bytes", ")", "#", "# Read 16-bit shorts until we get one with a low bit set to zero", "#", "flags", "=", "[", "]", "while", "1", ":", "flag_bits", "=", "r", ".", "read_short", "(", ")", "flags", ".", "append", "(", "flag_bits", ")", "if", "flag_bits", "&", "1", "==", "0", ":", "break", "shift", "=", "0", "d", "=", "{", "}", "for", "key", ",", "proptype", "in", "self", ".", "PROPERTIES", ":", "if", "shift", "==", "0", ":", "if", "not", "flags", ":", "break", "flag_bits", ",", "flags", "=", "flags", "[", "0", "]", ",", "flags", "[", "1", ":", "]", "shift", "=", "15", "if", "flag_bits", "&", "(", "1", "<<", "shift", ")", ":", "d", "[", "key", "]", "=", "getattr", "(", "r", ",", "'read_'", "+", "proptype", ")", "(", ")", "shift", "-=", "1", "self", ".", "properties", "=", "d" ]

[ "Given", "the", "raw", "bytes", "containing", "the", "property", "-", "flags", "and", "property", "-", "list", "from", "a", "content", "-", "frame", "-", "header", "parse", "and", "insert", "into", "a", "dictionary", "stored", "in", "this", "object", "as", "an", "attribute", "named", "properties", "." ]

[ "def", "get", "(", "self", ",", "storagemodel", ":", "object", ",", "modeldefinition", "=", "None", ",", "hide", "=", "0", ")", "->", "StorageQueueModel", ":", "try", ":", "if", "hide", ">", "0", ":", "messages", "=", "modeldefinition", "[", "'queueservice'", "]", ".", "get_messages", "(", "storagemodel", ".", "_queuename", ",", "num_messages", "=", "1", ",", "visibility_timeout", "=", "hide", ")", "else", ":", "messages", "=", "modeldefinition", "[", "'queueservice'", "]", ".", "get_messages", "(", "storagemodel", ".", "_queuename", ",", "num_messages", "=", "1", ")", "\"\"\" parse retrieved message \"\"\"", "for", "message", "in", "messages", ":", "storagemodel", ".", "mergemessage", "(", "message", ")", "\"\"\" no message retrieved ?\"\"\"", "if", "storagemodel", ".", "id", "is", "None", ":", "storagemodel", "=", "None", "except", "Exception", "as", "e", ":", "storagemodel", "=", "None", "msg", "=", "'can not peek queue message: queue {} with message {} because {!s}'", ".", "format", "(", "storagemodel", ".", "_queuename", ",", "storagemodel", ".", "content", ",", "e", ")", "raise", "AzureStorageWrapException", "(", "msg", "=", "msg", ")", "finally", ":", "return", "storagemodel" ]

[ "get", "the", "next", "message", "in", "queue" ]

[ "def", "diff_analysis", "(", "using", ")", ":", "python_analysis", "=", "collect_analysis", "(", "using", ")", "es_analysis", "=", "existing_analysis", "(", "using", ")", "return", "compare_dicts", "(", "es_analysis", ",", "python_analysis", ")" ]

[ "Returns", "a", "diff", "string", "comparing", "the", "analysis", "defined", "in", "ES", "with", "the", "analysis", "defined", "in", "Python", "land", "for", "the", "connection", "using" ]

[ "def", "SimpleHREF", "(", "self", ",", "elt", ",", "ps", ",", "tag", ")", ":", "if", "len", "(", "_children", "(", "elt", ")", ")", ":", "return", "elt", "href", "=", "_find_href", "(", "elt", ")", "if", "not", "href", ":", "if", "self", ".", "minOccurs", "is", "0", ":", "return", "None", "raise", "EvaluateException", "(", "'Required'", "+", "tag", "+", "' missing'", ",", "ps", ".", "Backtrace", "(", "elt", ")", ")", "return", "ps", ".", "FindLocalHREF", "(", "href", ",", "elt", ",", "0", ")" ]

[ "Simple", "HREF", "for", "non", "-", "string", "and", "non", "-", "struct", "and", "non", "-", "array", ".", "Parameters", ":", "elt", "--", "the", "DOM", "element", "being", "parsed", "ps", "--", "the", "ParsedSoap", "object", ".", "tag", "--" ]

[ "def", "mass_fractions", "(", "self", ")", ":", "if", "self", ".", "__mass_fractions", ":", "return", "self", ".", "__mass_fractions", "else", ":", "self", ".", "__mass_fractions", "=", "mass_fractions", "(", "self", ".", "atoms", ",", "self", ".", "MW", ")", "return", "self", ".", "__mass_fractions" ]

[ "r", "Dictionary", "of", "atom", ":", "mass", "-", "weighted", "fractional", "occurence", "of", "elements", ".", "Useful", "when", "performing", "mass", "balances", ".", "For", "atom", "-", "fraction", "occurences", "see", ":", "obj", ":", "atom_fractions", "." ]

[ "def", "motionDetected", "(", "self", ",", "home", "=", "None", ",", "camera", "=", "None", ")", ":", "try", ":", "cam_id", "=", "self", ".", "cameraByName", "(", "camera", "=", "camera", ",", "home", "=", "home", ")", "[", "'id'", "]", "except", "TypeError", ":", "logger", ".", "warning", "(", "\"personSeenByCamera: Camera name or home is unknown\"", ")", "return", "False", "if", "self", ".", "lastEvent", "[", "cam_id", "]", "[", "'type'", "]", "==", "'movement'", ":", "return", "True", "return", "False" ]

[ "Return", "True", "if", "movement", "has", "been", "detected" ]

[ "def", "travis", "(", "branch", ":", "str", ")", ":", "assert", "os", ".", "environ", ".", "get", "(", "'TRAVIS_BRANCH'", ")", "==", "branch", "assert", "os", ".", "environ", ".", "get", "(", "'TRAVIS_PULL_REQUEST'", ")", "==", "'false'" ]

[ "Performs", "necessary", "checks", "to", "ensure", "that", "the", "travis", "build", "is", "one", "that", "should", "create", "releases", "." ]

[ "async", "def", "download", "(", "self", ",", "files", ":", "Sequence", "[", "Union", "[", "str", ",", "Path", "]", "]", ",", "dest", ":", "Union", "[", "str", ",", "Path", "]", "=", "'.'", ",", "show_progress", ":", "bool", "=", "False", ")", ":", "params", "=", "{", "}", "if", "self", ".", "owner_access_key", ":", "params", "[", "'owner_access_key'", "]", "=", "self", ".", "owner_access_key", "rqst", "=", "Request", "(", "self", ".", "session", ",", "'GET'", ",", "'/kernel/{}/download'", ".", "format", "(", "self", ".", "kernel_id", ")", ",", "params", "=", "params", ")", "rqst", ".", "set_json", "(", "{", "'files'", ":", "[", "*", "map", "(", "str", ",", "files", ")", "]", ",", "}", ")", "async", "with", "rqst", ".", "fetch", "(", ")", "as", "resp", ":", "chunk_size", "=", "1", "*", "1024", "file_names", "=", "None", "tqdm_obj", "=", "tqdm", "(", "desc", "=", "'Downloading files'", ",", "unit", "=", "'bytes'", ",", "unit_scale", "=", "True", ",", "total", "=", "resp", ".", "content", ".", "total_bytes", ",", "disable", "=", "not", "show_progress", ")", "with", "tqdm_obj", "as", "pbar", ":", "fp", "=", "None", "while", "True", ":", "chunk", "=", "await", "resp", ".", "aread", "(", "chunk_size", ")", "if", "not", "chunk", ":", "break", "pbar", ".", "update", "(", "len", "(", "chunk", ")", ")", "# TODO: more elegant parsing of multipart response?", "for", "part", "in", "chunk", ".", "split", "(", "b'\\r\\n'", ")", ":", "if", "part", ".", "startswith", "(", "b'--'", ")", ":", "if", "fp", ":", "fp", ".", "close", "(", ")", "with", "tarfile", ".", "open", "(", "fp", ".", "name", ")", "as", "tarf", ":", "tarf", ".", "extractall", "(", "path", "=", "dest", ")", "file_names", "=", "tarf", ".", "getnames", "(", ")", "os", ".", "unlink", "(", "fp", ".", "name", ")", "fp", "=", "tempfile", ".", "NamedTemporaryFile", "(", "suffix", "=", "'.tar'", ",", "delete", "=", "False", ")", "elif", "part", ".", "startswith", "(", "b'Content-'", ")", "or", "part", "==", "b''", ":", "continue", "else", ":", "fp", ".", "write", "(", "part", ")", "if", "fp", ":", "fp", ".", "close", "(", ")", "os", ".", "unlink", "(", "fp", ".", "name", ")", "result", "=", "{", "'file_names'", ":", "file_names", "}", "return", "result" ]

[ "Downloads", "the", "given", "list", "of", "files", "from", "the", "compute", "session", "." ]

[ "def", "query", "(", "self", ",", "query", ")", ":", "self", ".", "logger", ".", "info", "(", "'%s: query %s'", "%", "(", "self", ",", "query", ")", ")", "return", "super", "(", "LoggingDatastore", ",", "self", ")", ".", "query", "(", "query", ")" ]

[ "Returns", "an", "iterable", "of", "objects", "matching", "criteria", "expressed", "in", "query", ".", "LoggingDatastore", "logs", "the", "access", "." ]

[ "def", "_readlines", "(", "fname", ",", "fpointer1", "=", "open", ",", "fpointer2", "=", "open", ")", ":", "# pragma: no cover", "# fpointer1, fpointer2 arguments to ease testing", "try", ":", "with", "fpointer1", "(", "fname", ",", "\"r\"", ")", "as", "fobj", ":", "return", "fobj", ".", "readlines", "(", ")", "except", "UnicodeDecodeError", ":", "# pragma: no cover", "with", "fpointer2", "(", "fname", ",", "\"r\"", ",", "encoding", "=", "\"utf-8\"", ")", "as", "fobj", ":", "return", "fobj", ".", "readlines", "(", ")" ]

[ "Read", "all", "lines", "from", "file", "." ]

[ "def", "cut_segments", "(", "x2d", ",", "tr", ",", "start", ",", "stop", ")", ":", "if", "start", "!=", "int", "(", "start", ")", ":", "raise", "ValueError", "(", "\"start index must be an integer\"", ")", "if", "stop", "!=", "int", "(", "stop", ")", ":", "raise", "ValueError", "(", "\"stop index must be an integer\"", ")", "x2d", "=", "np", ".", "atleast_2d", "(", "x2d", ")", "tr", "=", "np", ".", "asarray", "(", "tr", ",", "dtype", "=", "int", ")", ".", "ravel", "(", ")", "win", "=", "np", ".", "arange", "(", "start", ",", "stop", ",", "dtype", "=", "int", ")", "return", "np", ".", "concatenate", "(", "[", "x2d", "[", "np", ".", "newaxis", ",", ":", ",", "t", "+", "win", "]", "for", "t", "in", "tr", "]", ")" ]

[ "Cut", "continuous", "signal", "into", "segments", "." ]

[ "def", "sids", "(", "self", ")", ":", "if", "self", ".", "cid", ":", "results", "=", "get_json", "(", "self", ".", "cid", ",", "operation", "=", "'sids'", ")", "return", "results", "[", "'InformationList'", "]", "[", "'Information'", "]", "[", "0", "]", "[", "'SID'", "]", "if", "results", "else", "[", "]" ]

[ "Requires", "an", "extra", "request", ".", "Result", "is", "cached", "." ]

[ "def", "window_riesz", "(", "N", ")", ":", "n", "=", "linspace", "(", "-", "N", "/", "2.", ",", "(", "N", ")", "/", "2.", ",", "N", ")", "w", "=", "1", "-", "abs", "(", "n", "/", "(", "N", "/", "2.", ")", ")", "**", "2.", "return", "w" ]

[ "r", "Riesz", "tapering", "window" ]

[ "def", "_make_estimator_serving_session", "(", "estimator", ",", "serving_input_fn", ",", "checkpoint_path", ")", ":", "with", "tf", ".", "Graph", "(", ")", ".", "as_default", "(", ")", "as", "g", ":", "mode", "=", "tf_v1", ".", "estimator", ".", "ModeKeys", ".", "PREDICT", "tf_v1", ".", "train", ".", "create_global_step", "(", "g", ")", "tf_v1", ".", "set_random_seed", "(", "estimator", ".", "config", ".", "tf_random_seed", ")", "serving_input_receiver", "=", "serving_input_fn", "(", ")", "estimator_spec", "=", "estimator", ".", "model_fn", "(", "features", "=", "serving_input_receiver", ".", "features", ",", "labels", "=", "None", ",", "mode", "=", "mode", ",", "config", "=", "estimator", ".", "config", ")", "# pylint: disable=protected-access", "# Note that MonitoredSession(), despite the name is not a Session, and", "# can't be used to export Modules as one can't use them with Savers.", "# As so this must use a raw tf.Session().", "session", "=", "tf_v1", ".", "Session", "(", "config", "=", "estimator", ".", "_session_config", ")", "# pylint: enable=protected-access", "with", "session", ".", "as_default", "(", ")", ":", "# TODO(b/71839662): Consider if this needs to support TPUEstimatorSpec", "# which does not have a scaffold member.", "saver_for_restore", "=", "estimator_spec", ".", "scaffold", ".", "saver", "or", "tf_v1", ".", "train", ".", "Saver", "(", "sharded", "=", "True", ")", "saver_for_restore", ".", "restore", "(", "session", ",", "checkpoint_path", ")", "return", "session" ]

[ "Returns", "a", "session", "constructed", "using", "estimator", "and", "serving_input_fn", "." ]

[ "def", "fix", "(", "x", ",", "digs", ")", ":", "if", "type", "(", "x", ")", "!=", "type", "(", "''", ")", ":", "x", "=", "repr", "(", "x", ")", "try", ":", "sign", ",", "intpart", ",", "fraction", ",", "expo", "=", "extract", "(", "x", ")", "except", "NotANumber", ":", "return", "x", "intpart", ",", "fraction", "=", "unexpo", "(", "intpart", ",", "fraction", ",", "expo", ")", "intpart", ",", "fraction", "=", "roundfrac", "(", "intpart", ",", "fraction", ",", "digs", ")", "while", "intpart", "and", "intpart", "[", "0", "]", "==", "'0'", ":", "intpart", "=", "intpart", "[", "1", ":", "]", "if", "intpart", "==", "''", ":", "intpart", "=", "'0'", "if", "digs", ">", "0", ":", "return", "sign", "+", "intpart", "+", "'.'", "+", "fraction", "else", ":", "return", "sign", "+", "intpart" ]

[ "Format", "x", "as", "[", "-", "]", "ddd", ".", "ddd", "with", "digs", "digits", "after", "the", "point", "and", "at", "least", "one", "digit", "before", ".", "If", "digs", "<", "=", "0", "the", "point", "is", "suppressed", "." ]

[ "def", "assert_list", "(", "self", ",", "putative_list", ",", "expected_type", "=", "string_types", ",", "key_arg", "=", "None", ")", ":", "return", "assert_list", "(", "putative_list", ",", "expected_type", ",", "key_arg", "=", "key_arg", ",", "raise_type", "=", "lambda", "msg", ":", "TargetDefinitionException", "(", "self", ",", "msg", ")", ")" ]

[ ":", "API", ":", "public" ]

[ "def", "reserve", "(", "ctx", ",", "amount", ",", "symbol", ",", "account", ")", ":", "print_tx", "(", "ctx", ".", "bitshares", ".", "reserve", "(", "Amount", "(", "amount", ",", "symbol", ",", "bitshares_instance", "=", "ctx", ".", "bitshares", ")", ",", "account", "=", "account", ")", ")" ]

[ "Reserve", "/", "Burn", "tokens" ]

[ "def", "update_progressbar", "(", "self", ")", ":", "n", ",", "nmin", ",", "nmax", "=", "self", ".", "wprogressbar", ".", "n", ",", "self", ".", "wprogressbar", ".", "nmin", ",", "self", ".", "wprogressbar", ".", "nmax", "if", "(", "nmax", "-", "nmin", ")", "==", "0", ":", "percent", "=", "0", "# prevents ZeroDivisionError", "else", ":", "percent", "=", "max", "(", "min", "(", "(", "n", "-", "nmin", ")", "/", "(", "nmax", "-", "nmin", ")", ",", "1.", ")", ",", "0.", ")", "*", "100", "dat", "=", "{", "\"value\"", ":", "round", "(", "n", ",", "4", ")", ",", "\"n\"", ":", "round", "(", "n", ",", "4", ")", ",", "\"nmin\"", ":", "round", "(", "nmin", ",", "4", ")", ",", "\"nmax\"", ":", "round", "(", "nmax", ",", "4", ")", ",", "\"percent\"", ":", "round", "(", "percent", ",", "4", ")", ",", "\"p\"", ":", "round", "(", "percent", ",", "4", ")", "}", "txt", "=", "self", ".", "_label_progressbar", ".", "format", "(", "*", "*", "dat", ")", "self", ".", "wprogresslabel", ".", "label", "=", "txt" ]

[ "Updates", "the", "progressbar", "by", "re", "-", "calculating", "the", "label", ".", "It", "is", "not", "required", "to", "manually", "call", "this", "method", "since", "setting", "any", "of", "the", "properties", "of", "this", "class", "will", "automatically", "trigger", "a", "re", "-", "calculation", "." ]

[ "def", "get_reader_input_fn", "(", "train_config", ",", "preprocess_output_dir", ",", "model_type", ",", "data_paths", ",", "batch_size", ",", "shuffle", ",", "num_epochs", "=", "None", ")", ":", "def", "get_input_features", "(", ")", ":", "\"\"\"Read the input features from the given data paths.\"\"\"", "_", ",", "examples", "=", "util", ".", "read_examples", "(", "input_files", "=", "data_paths", ",", "batch_size", "=", "batch_size", ",", "shuffle", "=", "shuffle", ",", "num_epochs", "=", "num_epochs", ")", "features", "=", "util", ".", "parse_example_tensor", "(", "examples", "=", "examples", ",", "train_config", "=", "train_config", ",", "keep_target", "=", "True", ")", "target_name", "=", "train_config", "[", "'target_column'", "]", "target", "=", "features", ".", "pop", "(", "target_name", ")", "features", ",", "target", "=", "util", ".", "preprocess_input", "(", "features", "=", "features", ",", "target", "=", "target", ",", "train_config", "=", "train_config", ",", "preprocess_output_dir", "=", "preprocess_output_dir", ",", "model_type", "=", "model_type", ")", "return", "features", ",", "target", "# Return a function to input the feaures into the model from a data path.", "return", "get_input_features" ]

[ "Builds", "input", "layer", "for", "training", "." ]

[ "def", "_create_connections", "(", "self", ",", "graph_matrix", ")", ":", "for", "row", "in", "range", "(", "0", ",", "len", "(", "graph_matrix", ")", ")", ":", "for", "column", "in", "range", "(", "0", ",", "len", "(", "graph_matrix", "[", "row", "]", ")", ")", ":", "if", "(", "graph_matrix", "[", "row", "]", "[", "column", "]", ">", "0", ")", ":", "self", ".", "set_connection", "(", "row", ",", "column", ")" ]

[ "!" ]

[ "def", "get_data_dir", "(", ")", ":", "data_dir_paths", "=", "[", "os", ".", "path", ".", "join", "(", "os", ".", "path", ".", "dirname", "(", "ansiblecmdb", ".", "__file__", ")", ",", "'data'", ")", ",", "os", ".", "path", ".", "join", "(", "os", ".", "path", ".", "dirname", "(", "sys", ".", "argv", "[", "0", "]", ")", ",", "'..'", ",", "'lib'", ",", "'ansiblecmdb'", ",", "'data'", ")", ",", "'/usr/local/lib/ansiblecmdb/data'", ",", "'/usr/lib/ansiblecmdb/data'", ",", "]", "data_dir", "=", "util", ".", "find_path", "(", "data_dir_paths", ",", "'tpl/html_fancy.tpl'", ")", "if", "not", "data_dir", ":", "sys", ".", "stdout", ".", "write", "(", "\"Couldn't find the data dir for the templates. I tried: {0}\\n\"", ".", "format", "(", "\", \"", ".", "join", "(", "data_dir_paths", ")", ")", ")", "sys", ".", "exit", "(", "1", ")", "return", "data_dir" ]

[ "Find", "out", "our", "installation", "prefix", "and", "data", "directory", ".", "These", "can", "be", "in", "different", "places", "depending", "on", "how", "ansible", "-", "cmdb", "was", "installed", "." ]