Datasets:

---

kejian

/

codesearchnet-python-raw

like 1

[ "def", "collect", "(", "self", ")", ":", "if", "psycopg2", "is", "None", ":", "self", ".", "log", ".", "error", "(", "'Unable to import module psycopg2'", ")", "return", "{", "}", "# Get list of databases", "dbs", "=", "self", ".", "_get_db_names", "(", ")", "if", "len", "(", "dbs", ")", "==", "0", ":", "self", ".", "log", ".", "error", "(", "\"I have 0 databases!\"", ")", "return", "{", "}", "if", "self", ".", "config", "[", "'metrics'", "]", ":", "metrics", "=", "self", ".", "config", "[", "'metrics'", "]", "elif", "str_to_bool", "(", "self", ".", "config", "[", "'extended'", "]", ")", ":", "metrics", "=", "registry", "[", "'extended'", "]", "if", "str_to_bool", "(", "self", ".", "config", "[", "'has_admin'", "]", ")", "and", "'WalSegmentStats'", "not", "in", "metrics", ":", "metrics", ".", "append", "(", "'WalSegmentStats'", ")", "else", ":", "metrics", "=", "registry", "[", "'basic'", "]", "# Iterate every QueryStats class", "for", "metric_name", "in", "set", "(", "metrics", ")", ":", "if", "metric_name", "not", "in", "metrics_registry", ":", "self", ".", "log", ".", "error", "(", "'metric_name %s not found in metric registry'", "%", "metric_name", ")", "continue", "for", "dbase", "in", "dbs", ":", "conn", "=", "self", ".", "_connect", "(", "database", "=", "dbase", ")", "try", ":", "klass", "=", "metrics_registry", "[", "metric_name", "]", "stat", "=", "klass", "(", "dbase", ",", "conn", ",", "underscore", "=", "self", ".", "config", "[", "'underscore'", "]", ")", "stat", ".", "fetch", "(", "self", ".", "config", "[", "'pg_version'", "]", ")", "for", "metric", ",", "value", "in", "stat", ":", "if", "value", "is", "not", "None", ":", "self", ".", "publish", "(", "metric", ",", "value", ")", "# Setting multi_db to True will run this query on all known", "# databases. This is bad for queries that hit views like", "# pg_database, which are shared across databases.", "#", "# If multi_db is False, bail early after the first query", "# iteration. Otherwise, continue to remaining databases.", "if", "stat", ".", "multi_db", "is", "False", ":", "break", "finally", ":", "conn", ".", "close", "(", ")" ]

[ "Do", "pre", "-", "flight", "checks", "get", "list", "of", "db", "names", "collect", "metrics", "publish" ]

[ "def", "_remove_extraneous_xml_declarations", "(", "xml_str", ")", ":", "xml_declaration", "=", "''", "if", "xml_str", ".", "startswith", "(", "'<?xml'", ")", ":", "xml_declaration", ",", "xml_str", "=", "xml_str", ".", "split", "(", "'?>'", ",", "maxsplit", "=", "1", ")", "xml_declaration", "+=", "'?>'", "xml_str", "=", "re", ".", "sub", "(", "r'<\\?xml.*?\\?>'", ",", "''", ",", "xml_str", ",", "flags", "=", "re", ".", "I", ")", "return", "xml_declaration", "+", "xml_str" ]

[ "Sometimes", "devices", "return", "XML", "with", "more", "than", "one", "XML", "declaration", "in", "such", "as", "when", "returning", "their", "own", "XML", "config", "files", ".", "This", "removes", "the", "extra", "ones", "and", "preserves", "the", "first", "one", "." ]

[ "def", "_fetch_itemslist", "(", "self", ",", "item", ")", ":", "if", "item", ".", "is_root", ":", "for", "c", "in", "[", "\"Arbetsolycka\"", ",", "\"Arbetssjukdom\"", "]", ":", "yield", "Collection", "(", "c", ",", "blob", "=", "(", "c", ",", "None", ",", "None", ")", ")", "else", ":", "c", "=", "item", ".", "id", "for", "r", "in", "[", "u\"kommun\"", ",", "u\"län\"]", ":", "", "for", "p", "in", "[", "u\"år\",", " ", "\"månad\"]:", "", "", "yield", "Dataset", "(", "u\"%s-%s-%s\"", "%", "(", "c", ",", "r", ",", "p", ")", ",", "blob", "=", "(", "c", ",", "r", ",", "p", ")", ",", "label", "=", "u\"%s, antal per %s och %s\"", "%", "(", "c", ",", "r", ",", "p", ")", ")" ]

[ "We", "define", "two", "collection", ":", "-", "Number", "of", "work", "injuries", "(", "Arbetsolycka", ")", "-", "Number", "of", "workrelated", "diseases", "(", "Arbetssjukdom", ")", "Each", "contains", "four", "datasets", ":", "-", "Per", "municipality", "and", "year", "-", "Per", "county", "and", "year", "-", "Per", "municipality", "and", "month", "-", "Per", "municipality", "and", "year" ]

[ "def", "pay_order_query", "(", "self", ",", "out_trade_no", ")", ":", "package", "=", "{", "'partner'", ":", "self", ".", "pay_partner_id", ",", "'out_trade_no'", ":", "out_trade_no", ",", "}", "_package", "=", "package", ".", "items", "(", ")", "_package", ".", "sort", "(", ")", "s", "=", "'&'", ".", "join", "(", "[", "\"%s=%s\"", "%", "(", "p", "[", "0", "]", ",", "str", "(", "p", "[", "1", "]", ")", ")", "for", "p", "in", "(", "_package", "+", "[", "(", "'key'", ",", "self", ".", "pay_partner_key", ")", "]", ")", "]", ")", "package", "[", "'sign'", "]", "=", "md5", "(", "s", ")", ".", "hexdigest", "(", ")", ".", "upper", "(", ")", "package", "=", "'&'", ".", "join", "(", "[", "\"%s=%s\"", "%", "(", "p", "[", "0", "]", ",", "p", "[", "1", "]", ")", "for", "p", "in", "package", ".", "items", "(", ")", "]", ")", "params", ",", "sign", ",", "_", "=", "self", ".", "_pay_sign_dict", "(", "add_noncestr", "=", "False", ",", "package", "=", "package", ")", "params", "[", "'app_signature'", "]", "=", "sign", "params", "[", "'sign_method'", "]", "=", "'sha1'", "return", "self", ".", "post", "(", "url", "=", "\"https://api.weixin.qq.com/pay/orderquery\"", ",", "data", "=", "params", ")" ]

[ "查询订单状态", "一般用于无法确定", "订单状态时候补偿" ]

[ "def", "_get_path", "(", "fname", ":", "str", ")", "->", "str", ":", "path", "=", "get_corpus_path", "(", "fname", ")", "if", "not", "path", ":", "download", "(", "fname", ")", "path", "=", "get_corpus_path", "(", "fname", ")", "return", "path" ]

[ ":", "meth", ":", "download", "get", "path", "of", "file", "from", "pythainlp", "-", "corpus", ":", "param", "str", "fname", ":", "file", "name", ":", "return", ":", "path", "to", "downloaded", "file" ]

[ "def", "on", "(", "self", ",", "image", ")", ":", "shape", "=", "normalize_shape", "(", "image", ")", "if", "shape", "[", "0", ":", "2", "]", "==", "self", ".", "shape", "[", "0", ":", "2", "]", ":", "return", "self", ".", "deepcopy", "(", ")", "polygons", "=", "[", "poly", ".", "project", "(", "self", ".", "shape", ",", "shape", ")", "for", "poly", "in", "self", ".", "polygons", "]", "# TODO use deepcopy() here", "return", "PolygonsOnImage", "(", "polygons", ",", "shape", ")" ]

[ "Project", "polygons", "from", "one", "image", "to", "a", "new", "one", "." ]

[ "def", "run_muse", "(", "job", ",", "tumor_bam", ",", "normal_bam", ",", "univ_options", ",", "muse_options", ")", ":", "# Get a list of chromosomes to handle", "if", "muse_options", "[", "'chromosomes'", "]", ":", "chromosomes", "=", "muse_options", "[", "'chromosomes'", "]", "else", ":", "chromosomes", "=", "sample_chromosomes", "(", "job", ",", "muse_options", "[", "'genome_fai'", "]", ")", "perchrom_muse", "=", "defaultdict", "(", ")", "for", "chrom", "in", "chromosomes", ":", "call", "=", "job", ".", "addChildJobFn", "(", "run_muse_perchrom", ",", "tumor_bam", ",", "normal_bam", ",", "univ_options", ",", "muse_options", ",", "chrom", ",", "disk", "=", "PromisedRequirement", "(", "muse_disk", ",", "tumor_bam", "[", "'tumor_dna_fix_pg_sorted.bam'", "]", ",", "normal_bam", "[", "'normal_dna_fix_pg_sorted.bam'", "]", ",", "muse_options", "[", "'genome_fasta'", "]", ")", ",", "memory", "=", "'6G'", ")", "sump", "=", "call", ".", "addChildJobFn", "(", "run_muse_sump_perchrom", ",", "call", ".", "rv", "(", ")", ",", "univ_options", ",", "muse_options", ",", "chrom", ",", "disk", "=", "PromisedRequirement", "(", "muse_sump_disk", ",", "muse_options", "[", "'dbsnp_vcf'", "]", ")", ",", "memory", "=", "'6G'", ")", "perchrom_muse", "[", "chrom", "]", "=", "sump", ".", "rv", "(", ")", "return", "perchrom_muse" ]

[ "Spawn", "a", "MuSE", "job", "for", "each", "chromosome", "on", "the", "DNA", "bams", "." ]

[ "def", "ServiceWorker_stopWorker", "(", "self", ",", "versionId", ")", ":", "assert", "isinstance", "(", "versionId", ",", "(", "str", ",", ")", ")", ",", "\"Argument 'versionId' must be of type '['str']'. Received type: '%s'\"", "%", "type", "(", "versionId", ")", "subdom_funcs", "=", "self", ".", "synchronous_command", "(", "'ServiceWorker.stopWorker'", ",", "versionId", "=", "versionId", ")", "return", "subdom_funcs" ]

[ "Function", "path", ":", "ServiceWorker", ".", "stopWorker", "Domain", ":", "ServiceWorker", "Method", "name", ":", "stopWorker", "Parameters", ":", "Required", "arguments", ":", "versionId", "(", "type", ":", "string", ")", "-", ">", "No", "description", "No", "return", "value", "." ]

[ "def", "switch_keystone_provider", "(", "request", ",", "keystone_provider", "=", "None", ",", "redirect_field_name", "=", "auth", ".", "REDIRECT_FIELD_NAME", ")", ":", "base_token", "=", "request", ".", "session", ".", "get", "(", "'k2k_base_unscoped_token'", ",", "None", ")", "k2k_auth_url", "=", "request", ".", "session", ".", "get", "(", "'k2k_auth_url'", ",", "None", ")", "keystone_providers", "=", "request", ".", "session", ".", "get", "(", "'keystone_providers'", ",", "None", ")", "recent_project", "=", "request", ".", "COOKIES", ".", "get", "(", "'recent_project'", ")", "if", "not", "base_token", "or", "not", "k2k_auth_url", ":", "msg", "=", "_", "(", "'K2K Federation not setup for this session'", ")", "raise", "exceptions", ".", "KeystoneAuthException", "(", "msg", ")", "redirect_to", "=", "request", ".", "GET", ".", "get", "(", "redirect_field_name", ",", "''", ")", "if", "not", "is_safe_url", "(", "url", "=", "redirect_to", ",", "host", "=", "request", ".", "get_host", "(", ")", ")", ":", "redirect_to", "=", "settings", ".", "LOGIN_REDIRECT_URL", "unscoped_auth_ref", "=", "None", "keystone_idp_id", "=", "getattr", "(", "settings", ",", "'KEYSTONE_PROVIDER_IDP_ID'", ",", "'localkeystone'", ")", "if", "keystone_provider", "==", "keystone_idp_id", ":", "current_plugin", "=", "plugin", ".", "TokenPlugin", "(", ")", "unscoped_auth", "=", "current_plugin", ".", "get_plugin", "(", "auth_url", "=", "k2k_auth_url", ",", "token", "=", "base_token", ")", "else", ":", "# Switch to service provider using K2K federation", "plugins", "=", "[", "plugin", ".", "TokenPlugin", "(", ")", "]", "current_plugin", "=", "plugin", ".", "K2KAuthPlugin", "(", ")", "unscoped_auth", "=", "current_plugin", ".", "get_plugin", "(", "auth_url", "=", "k2k_auth_url", ",", "service_provider", "=", "keystone_provider", ",", "plugins", "=", "plugins", ",", "token", "=", "base_token", ",", "recent_project", "=", "recent_project", ")", "try", ":", "# Switch to identity provider using token auth", "unscoped_auth_ref", "=", "current_plugin", ".", "get_access_info", "(", "unscoped_auth", ")", "except", "exceptions", ".", "KeystoneAuthException", "as", "exc", ":", "msg", "=", "'Switching to Keystone Provider %s has failed. %s'", "%", "(", "keystone_provider", ",", "(", "six", ".", "text_type", "(", "exc", ")", ")", ")", "messages", ".", "error", "(", "request", ",", "msg", ")", "if", "unscoped_auth_ref", ":", "try", ":", "request", ".", "user", "=", "auth", ".", "authenticate", "(", "request", "=", "request", ",", "auth_url", "=", "unscoped_auth", ".", "auth_url", ",", "token", "=", "unscoped_auth_ref", ".", "auth_token", ")", "except", "exceptions", ".", "KeystoneAuthException", "as", "exc", ":", "msg", "=", "'Keystone provider switch failed: %s'", "%", "six", ".", "text_type", "(", "exc", ")", "res", "=", "django_http", ".", "HttpResponseRedirect", "(", "settings", ".", "LOGIN_URL", ")", "res", ".", "set_cookie", "(", "'logout_reason'", ",", "msg", ",", "max_age", "=", "10", ")", "return", "res", "auth", ".", "login", "(", "request", ",", "request", ".", "user", ")", "auth_user", ".", "set_session_from_user", "(", "request", ",", "request", ".", "user", ")", "request", ".", "session", "[", "'keystone_provider_id'", "]", "=", "keystone_provider", "request", ".", "session", "[", "'keystone_providers'", "]", "=", "keystone_providers", "request", ".", "session", "[", "'k2k_base_unscoped_token'", "]", "=", "base_token", "request", ".", "session", "[", "'k2k_auth_url'", "]", "=", "k2k_auth_url", "message", "=", "(", "_", "(", "'Switch to Keystone Provider \"%(keystone_provider)s\" '", "'successful.'", ")", "%", "{", "'keystone_provider'", ":", "keystone_provider", "}", ")", "messages", ".", "success", "(", "request", ",", "message", ")", "response", "=", "shortcuts", ".", "redirect", "(", "redirect_to", ")", "return", "response" ]

[ "Switches", "the", "user", "s", "keystone", "provider", "using", "K2K", "Federation" ]

[ "def", "publish", "(", "self", ",", "service", ",", "routing_id", ",", "method", ",", "args", "=", "None", ",", "kwargs", "=", "None", ",", "broadcast", "=", "False", ",", "udp", "=", "False", ")", ":", "if", "udp", ":", "func", "=", "self", ".", "_dispatcher", ".", "send_publish_udp", "else", ":", "func", "=", "self", ".", "_dispatcher", ".", "send_publish", "if", "not", "func", "(", "None", ",", "service", ",", "routing_id", ",", "method", ",", "args", "or", "(", ")", ",", "kwargs", "or", "{", "}", ",", "singular", "=", "not", "broadcast", ")", ":", "raise", "errors", ".", "Unroutable", "(", ")" ]

[ "Send", "a", "1", "-", "way", "message" ]

[ "def", "_single_resource_json_response", "(", "resource", ",", "depth", "=", "0", ")", ":", "links", "=", "resource", ".", "links", "(", ")", "response", "=", "jsonify", "(", "*", "*", "resource", ".", "as_dict", "(", "depth", ")", ")", "response", ".", "headers", "[", "'Link'", "]", "=", "''", "for", "link", "in", "links", ":", "response", ".", "headers", "[", "'Link'", "]", "+=", "'<{}>; rel=\"{}\",'", ".", "format", "(", "link", "[", "'uri'", "]", ",", "link", "[", "'rel'", "]", ")", "response", ".", "headers", "[", "'Link'", "]", "=", "response", ".", "headers", "[", "'Link'", "]", "[", ":", "-", "1", "]", "return", "response" ]

[ "Return", "the", "JSON", "representation", "of", "*", "resource", "*", "." ]

[ "def", "usearch_qf", "(", "fasta_filepath", ",", "refseqs_fp", "=", "None", ",", "output_dir", "=", "None", ",", "percent_id", "=", "0.97", ",", "percent_id_err", "=", "0.97", ",", "minsize", "=", "4", ",", "abundance_skew", "=", "2.0", ",", "db_filepath", "=", "None", ",", "rev", "=", "False", ",", "label_prefix", "=", "\"\"", ",", "label_suffix", "=", "\"\"", ",", "retain_label_as_comment", "=", "False", ",", "count_start", "=", "0", ",", "perc_id_blast", "=", "0.97", ",", "save_intermediate_files", "=", "False", ",", "HALT_EXEC", "=", "False", ",", "global_alignment", "=", "True", ",", "sizein", "=", "True", ",", "sizeout", "=", "True", ",", "w", "=", "64", ",", "slots", "=", "16769023", ",", "maxrejects", "=", "64", ",", "minlen", "=", "64", ",", "de_novo_chimera_detection", "=", "True", ",", "derep_fullseq", "=", "False", ",", "reference_chimera_detection", "=", "True", ",", "cluster_size_filtering", "=", "True", ",", "remove_usearch_logs", "=", "False", ",", "usersort", "=", "True", ",", "suppress_new_clusters", "=", "False", ",", "chimeras_retention", "=", "\"union\"", ",", "verbose", "=", "False", ")", ":", "# Save a list of intermediate filepaths in case they are to be removed.", "intermediate_files", "=", "[", "]", "# Need absolute paths to avoid problems with app controller", "if", "output_dir", ":", "output_dir", "=", "abspath", "(", "output_dir", ")", "+", "'/'", "fasta_filepath", "=", "abspath", "(", "fasta_filepath", ")", "try", ":", "if", "verbose", ":", "print", "\"Sorting sequences by length...\"", "# Sort seqs by length", "app_result", ",", "output_filepath_len_sorted", "=", "usearch_fasta_sort_from_filepath", "(", "fasta_filepath", ",", "output_filepath", "=", "join", "(", "output_dir", ",", "'len_sorted.fasta'", ")", ",", "save_intermediate_files", "=", "save_intermediate_files", ",", "remove_usearch_logs", "=", "remove_usearch_logs", ",", "working_dir", "=", "output_dir", ",", "HALT_EXEC", "=", "HALT_EXEC", ")", "intermediate_files", ".", "append", "(", "output_filepath_len_sorted", ")", "if", "verbose", ":", "print", "\"Dereplicating sequences...\"", "# Dereplicate sequences", "app_result", ",", "output_filepath_dereplicated", "=", "usearch_dereplicate_exact_subseqs", "(", "output_filepath_len_sorted", ",", "output_filepath", "=", "join", "(", "output_dir", ",", "'dereplicated_seqs.fasta'", ")", ",", "minlen", "=", "minlen", ",", "w", "=", "w", ",", "slots", "=", "slots", ",", "sizeout", "=", "sizeout", ",", "maxrejects", "=", "maxrejects", ",", "save_intermediate_files", "=", "save_intermediate_files", ",", "remove_usearch_logs", "=", "remove_usearch_logs", ",", "working_dir", "=", "output_dir", ",", "HALT_EXEC", "=", "HALT_EXEC", ")", "intermediate_files", ".", "append", "(", "output_filepath_dereplicated", ")", "if", "verbose", ":", "print", "\"Sorting by abundance...\"", "# Sort by abundance, initially no filter based on seqs/otu", "app_result", ",", "output_fp", "=", "usearch_sort_by_abundance", "(", "output_filepath_dereplicated", ",", "output_filepath", "=", "join", "(", "output_dir", ",", "'abundance_sorted.fasta'", ")", ",", "usersort", "=", "True", ",", "sizein", "=", "sizein", ",", "sizeout", "=", "sizeout", ",", "minsize", "=", "0", ",", "remove_usearch_logs", "=", "remove_usearch_logs", ",", "working_dir", "=", "output_dir", ",", "HALT_EXEC", "=", "HALT_EXEC", ")", "intermediate_files", ".", "append", "(", "output_fp", ")", "if", "verbose", ":", "print", "\"Clustering sequences for error correction...\"", "# Create .uc file of clusters file, to identify original sequences", "# later", "output_uc_filepath", "=", "output_dir", "+", "'err_corrected_clusters.uc'", "app_result", ",", "error_clustered_output_fp", "=", "usearch_cluster_error_correction", "(", "output_fp", ",", "output_filepath", "=", "join", "(", "output_dir", ",", "'clustered_error_corrected.fasta'", ")", ",", "output_uc_filepath", "=", "output_uc_filepath", ",", "usersort", "=", "True", ",", "percent_id_err", "=", "percent_id_err", ",", "sizein", "=", "sizein", ",", "sizeout", "=", "sizeout", ",", "w", "=", "w", ",", "slots", "=", "slots", ",", "maxrejects", "=", "maxrejects", ",", "remove_usearch_logs", "=", "remove_usearch_logs", ",", "save_intermediate_files", "=", "save_intermediate_files", ",", "working_dir", "=", "output_dir", ",", "HALT_EXEC", "=", "HALT_EXEC", ")", "intermediate_files", ".", "append", "(", "error_clustered_output_fp", ")", "intermediate_files", ".", "append", "(", "output_uc_filepath", ")", "# Series of conditional tests, using generic 'output_fp' name so the", "# conditional filtering, if any/all are selected, do not matter.", "if", "de_novo_chimera_detection", ":", "if", "verbose", ":", "print", "\"Performing de novo chimera detection...\"", "app_result", ",", "output_fp_de_novo_nonchimeras", "=", "usearch_chimera_filter_de_novo", "(", "error_clustered_output_fp", ",", "abundance_skew", "=", "abundance_skew", ",", "output_chimera_filepath", "=", "join", "(", "output_dir", ",", "'de_novo_chimeras.fasta'", ")", ",", "output_non_chimera_filepath", "=", "join", "(", "output_dir", ",", "'de_novo_non_chimeras.fasta'", ")", ",", "usersort", "=", "True", ",", "save_intermediate_files", "=", "save_intermediate_files", ",", "remove_usearch_logs", "=", "remove_usearch_logs", ",", "working_dir", "=", "output_dir", ",", "HALT_EXEC", "=", "HALT_EXEC", ")", "intermediate_files", ".", "append", "(", "output_fp_de_novo_nonchimeras", ")", "output_fp", "=", "output_fp_de_novo_nonchimeras", "if", "reference_chimera_detection", ":", "if", "verbose", ":", "print", "\"Performing reference based chimera detection...\"", "app_result", ",", "output_fp_ref_nonchimeras", "=", "usearch_chimera_filter_ref_based", "(", "error_clustered_output_fp", ",", "db_filepath", "=", "db_filepath", ",", "output_chimera_filepath", "=", "join", "(", "output_dir", ",", "'reference_chimeras.fasta'", ")", ",", "output_non_chimera_filepath", "=", "join", "(", "output_dir", ",", "'reference_non_chimeras.fasta'", ")", ",", "usersort", "=", "True", ",", "save_intermediate_files", "=", "save_intermediate_files", ",", "rev", "=", "rev", ",", "remove_usearch_logs", "=", "remove_usearch_logs", ",", "working_dir", "=", "output_dir", ",", "HALT_EXEC", "=", "HALT_EXEC", ")", "intermediate_files", ".", "append", "(", "output_fp_ref_nonchimeras", ")", "output_fp", "=", "output_fp_ref_nonchimeras", "# get intersection or union if both ref and de novo chimera detection", "if", "de_novo_chimera_detection", "and", "reference_chimera_detection", ":", "if", "verbose", ":", "print", "\"Finding %s of non-chimeras...\"", "%", "chimeras_retention", "output_fp", "=", "get_retained_chimeras", "(", "output_fp_de_novo_nonchimeras", ",", "output_fp_ref_nonchimeras", ",", "output_combined_fp", "=", "join", "(", "output_dir", ",", "'combined_non_chimeras.fasta'", ")", ",", "chimeras_retention", "=", "chimeras_retention", ")", "intermediate_files", ".", "append", "(", "output_fp", ")", "if", "cluster_size_filtering", ":", "# Test for empty filepath following filters, raise error if all seqs", "# have been removed", "if", "verbose", ":", "print", "\"Filtering by cluster size...\"", "# chimera detection was not performed, use output file of step 4 as input", "# to filtering by cluster size", "if", "not", "(", "reference_chimera_detection", "and", "de_novo_chimera_detection", ")", ":", "output_fp", "=", "error_clustered_output_fp", "app_result", ",", "output_fp", "=", "usearch_sort_by_abundance", "(", "output_fp", ",", "output_filepath", "=", "join", "(", "output_dir", ",", "'abundance_sorted_minsize_'", "+", "str", "(", "minsize", ")", "+", "'.fasta'", ")", ",", "minsize", "=", "minsize", ",", "sizein", "=", "sizein", ",", "sizeout", "=", "sizeout", ",", "remove_usearch_logs", "=", "remove_usearch_logs", ",", "working_dir", "=", "output_dir", ",", "HALT_EXEC", "=", "HALT_EXEC", ")", "intermediate_files", ".", "append", "(", "output_fp", ")", "# cluster seqs", "# Should we add in option to use alternative OTU picking here?", "# Seems like it will be a bit of a mess...maybe after we determine", "# if usearch_qf should become standard.", "if", "refseqs_fp", ":", "if", "verbose", ":", "print", "\"Clustering against reference sequences...\"", "app_result", ",", "output_filepath", "=", "usearch_cluster_seqs_ref", "(", "output_fp", ",", "output_filepath", "=", "join", "(", "output_dir", ",", "'ref_clustered_seqs.uc'", ")", ",", "percent_id", "=", "percent_id", ",", "sizein", "=", "sizein", ",", "sizeout", "=", "sizeout", ",", "w", "=", "w", ",", "slots", "=", "slots", ",", "maxrejects", "=", "maxrejects", ",", "save_intermediate_files", "=", "save_intermediate_files", ",", "remove_usearch_logs", "=", "remove_usearch_logs", ",", "suppress_new_clusters", "=", "suppress_new_clusters", ",", "refseqs_fp", "=", "refseqs_fp", ",", "output_dir", "=", "output_dir", ",", "working_dir", "=", "output_dir", ",", "rev", "=", "rev", ",", "HALT_EXEC", "=", "HALT_EXEC", ")", "else", ":", "if", "verbose", ":", "print", "\"De novo clustering sequences...\"", "app_result", ",", "output_filepath", "=", "usearch_cluster_seqs", "(", "output_fp", ",", "output_filepath", "=", "join", "(", "output_dir", ",", "'clustered_seqs.fasta'", ")", ",", "percent_id", "=", "percent_id", ",", "sizein", "=", "sizein", ",", "sizeout", "=", "sizeout", ",", "w", "=", "w", ",", "slots", "=", "slots", ",", "maxrejects", "=", "maxrejects", ",", "save_intermediate_files", "=", "save_intermediate_files", ",", "remove_usearch_logs", "=", "remove_usearch_logs", ",", "working_dir", "=", "output_dir", ",", "HALT_EXEC", "=", "HALT_EXEC", ")", "intermediate_files", ".", "append", "(", "output_filepath", ")", "# Enumerate the OTUs in the clusters", "if", "not", "suppress_new_clusters", ":", "if", "verbose", ":", "print", "\"Enumerating OTUs...\"", "output_filepath", "=", "enumerate_otus", "(", "output_filepath", ",", "output_filepath", "=", "join", "(", "output_dir", ",", "'enumerated_otus.fasta'", ")", ",", "label_prefix", "=", "label_prefix", ",", "label_suffix", "=", "label_suffix", ",", "count_start", "=", "count_start", ",", "retain_label_as_comment", "=", "retain_label_as_comment", ")", "intermediate_files", ".", "append", "(", "output_filepath", ")", "# Get original sequence label identities", "if", "verbose", ":", "print", "\"Assigning sequences to clusters...\"", "app_result", ",", "clusters_file", "=", "assign_reads_to_otus", "(", "fasta_filepath", ",", "filtered_fasta", "=", "output_filepath", ",", "output_filepath", "=", "join", "(", "output_dir", ",", "'assign_reads_to_otus.uc'", ")", ",", "perc_id_blast", "=", "percent_id", ",", "global_alignment", "=", "global_alignment", ",", "remove_usearch_logs", "=", "remove_usearch_logs", ",", "working_dir", "=", "output_dir", ",", "HALT_EXEC", "=", "HALT_EXEC", ")", "intermediate_files", ".", "append", "(", "clusters_file", ")", "except", "ApplicationError", ":", "raise", "ApplicationError", "(", "'Error running usearch. Possible causes are '", "'unsupported version (current supported version is usearch '", "+", "'v5.2.236) is installed or improperly formatted input file was '", "+", "'provided'", ")", "except", "ApplicationNotFoundError", ":", "remove_files", "(", "files_to_remove", ")", "raise", "ApplicationNotFoundError", "(", "'usearch not found, is it properly '", "+", "'installed?'", ")", "# Get dict of clusters, list of failures", "# Set OTU ID field to 9 for the case of closed reference OTU picking", "if", "suppress_new_clusters", ":", "otu_id_field", "=", "9", "else", ":", "otu_id_field", "=", "1", "clusters", ",", "failures", "=", "clusters_from_blast_uc_file", "(", "open", "(", "clusters_file", ",", "\"U\"", ")", ",", "otu_id_field", ")", "# Remove temp files unless user specifies output filepath", "if", "not", "save_intermediate_files", ":", "remove_files", "(", "intermediate_files", ")", "return", "clusters", ",", "failures" ]

[ "Main", "convenience", "wrapper", "for", "using", "usearch", "to", "filter", "/", "cluster", "seqs" ]

[ "def", "asmono", "(", "samples", ":", "np", ".", "ndarray", ",", "channel", ":", "Union", "[", "int", ",", "str", "]", "=", "0", ")", "->", "np", ".", "ndarray", ":", "if", "numchannels", "(", "samples", ")", "==", "1", ":", "# it could be [1,2,3,4,...], or [[1], [2], [3], [4], ...]", "if", "isinstance", "(", "samples", "[", "0", "]", ",", "float", ")", ":", "return", "samples", "elif", "isinstance", "(", "samples", "[", "0", "]", ",", "np", ".", "dnarray", ")", ":", "return", "np", ".", "reshape", "(", "samples", ",", "(", "len", "(", "samples", ")", ",", ")", ")", "else", ":", "raise", "TypeError", "(", "\"Samples should be numeric, found: %s\"", "%", "str", "(", "type", "(", "samples", "[", "0", "]", ")", ")", ")", "if", "isinstance", "(", "channel", ",", "int", ")", ":", "return", "samples", "[", ":", ",", "channel", "]", "elif", "channel", "==", "'mix'", ":", "return", "_mix", "(", "samples", ",", "scale_by_numchannels", "=", "True", ")", "else", ":", "raise", "ValueError", "(", "\"channel has to be an integer indicating a channel,\"", "\" or 'mix' to mix down all channels\"", ")" ]

[ "convert", "samples", "to", "mono", "if", "they", "are", "not", "mono", "already", "." ]

[ "def", "_runshell", "(", "cmd", ",", "exception", ")", ":", "p", "=", "subprocess", ".", "Popen", "(", "cmd", ",", "stdout", "=", "subprocess", ".", "PIPE", ",", "stderr", "=", "subprocess", ".", "PIPE", ")", "if", "p", ".", "wait", "(", ")", "!=", "0", ":", "raise", "BridgeException", "(", "exception", ")", "return", "p" ]

[ "Run", "a", "shell", "command", ".", "if", "fails", "raise", "a", "proper", "exception", "." ]

[ "def", "_change_sel_color", "(", "self", ",", "event", ")", ":", "(", "r", ",", "g", ",", "b", ")", ",", "(", "h", ",", "s", ",", "v", ")", ",", "color", "=", "self", ".", "square", ".", "get", "(", ")", "self", ".", "red", ".", "set", "(", "r", ")", "self", ".", "green", ".", "set", "(", "g", ")", "self", ".", "blue", ".", "set", "(", "b", ")", "self", ".", "saturation", ".", "set", "(", "s", ")", "self", ".", "value", ".", "set", "(", "v", ")", "self", ".", "hexa", ".", "delete", "(", "0", ",", "\"end\"", ")", "self", ".", "hexa", ".", "insert", "(", "0", ",", "color", ".", "upper", "(", ")", ")", "if", "self", ".", "alpha_channel", ":", "self", ".", "alphabar", ".", "set_color", "(", "(", "r", ",", "g", ",", "b", ")", ")", "self", ".", "hexa", ".", "insert", "(", "'end'", ",", "(", "\"%2.2x\"", "%", "self", ".", "alpha", ".", "get", "(", ")", ")", ".", "upper", "(", ")", ")", "self", ".", "_update_preview", "(", ")" ]

[ "Respond", "to", "motion", "of", "the", "color", "selection", "cross", "." ]

[ "def", "isValue", "(", "self", ")", ":", "for", "componentValue", "in", "self", ".", "_componentValues", ":", "if", "componentValue", "is", "noValue", "or", "not", "componentValue", ".", "isValue", ":", "return", "False", "return", "True" ]

[ "Indicate", "that", "|ASN", ".", "1|", "object", "represents", "ASN", ".", "1", "value", "." ]

[ "def", "_unbind", "(", "cls", ",", "boundname", ")", ":", "try", ":", "fs", "=", "CPE2_3_FS", "(", "boundname", ")", "except", ":", "# CPE name is not formatted string", "try", ":", "uri", "=", "CPE2_3_URI", "(", "boundname", ")", "except", ":", "# CPE name is not URI but WFN", "return", "CPE2_3_WFN", "(", "boundname", ")", "else", ":", "return", "CPE2_3_WFN", "(", "uri", ".", "as_wfn", "(", ")", ")", "else", ":", "return", "CPE2_3_WFN", "(", "fs", ".", "as_wfn", "(", ")", ")" ]

[ "Unbinds", "a", "bound", "form", "to", "a", "WFN", "." ]

[ "def", "set_property_value", "(", "self", ",", "name", ",", "value", ",", "dry_run", "=", "False", ")", ":", "raise", "DAVError", "(", "HTTP_FORBIDDEN", ",", "err_condition", "=", "PRECONDITION_CODE_ProtectedProperty", ")" ]

[ "Set", "or", "remove", "property", "value", "." ]

[ "def", "create_css", "(", "self", ",", "rules", ")", ":", "style", "=", "rules", "[", "0", "]", ".", "legacy_compiler_options", ".", "get", "(", "'style'", ",", "self", ".", "compiler", ".", "output_style", ")", "debug_info", "=", "self", ".", "compiler", ".", "generate_source_map", "if", "style", "==", "'legacy'", ":", "sc", ",", "sp", ",", "tb", ",", "nst", ",", "srnl", ",", "nl", ",", "rnl", ",", "lnl", ",", "dbg", "=", "True", ",", "' '", ",", "' '", ",", "False", ",", "''", ",", "'\\n'", ",", "'\\n'", ",", "'\\n'", ",", "debug_info", "elif", "style", "==", "'compressed'", ":", "sc", ",", "sp", ",", "tb", ",", "nst", ",", "srnl", ",", "nl", ",", "rnl", ",", "lnl", ",", "dbg", "=", "False", ",", "''", ",", "''", ",", "False", ",", "''", ",", "''", ",", "''", ",", "''", ",", "False", "elif", "style", "==", "'compact'", ":", "sc", ",", "sp", ",", "tb", ",", "nst", ",", "srnl", ",", "nl", ",", "rnl", ",", "lnl", ",", "dbg", "=", "True", ",", "' '", ",", "''", ",", "False", ",", "'\\n'", ",", "' '", ",", "'\\n'", ",", "' '", ",", "debug_info", "elif", "style", "==", "'expanded'", ":", "sc", ",", "sp", ",", "tb", ",", "nst", ",", "srnl", ",", "nl", ",", "rnl", ",", "lnl", ",", "dbg", "=", "True", ",", "' '", ",", "' '", ",", "False", ",", "'\\n'", ",", "'\\n'", ",", "'\\n'", ",", "'\\n'", ",", "debug_info", "else", ":", "# if style == 'nested':", "sc", ",", "sp", ",", "tb", ",", "nst", ",", "srnl", ",", "nl", ",", "rnl", ",", "lnl", ",", "dbg", "=", "True", ",", "' '", ",", "' '", ",", "True", ",", "'\\n'", ",", "'\\n'", ",", "'\\n'", ",", "' '", ",", "debug_info", "return", "self", ".", "_create_css", "(", "rules", ",", "sc", ",", "sp", ",", "tb", ",", "nst", ",", "srnl", ",", "nl", ",", "rnl", ",", "lnl", ",", "dbg", ")" ]

[ "Generate", "the", "final", "CSS", "string" ]

[ "def", "_analyzeDontMeasure", "(", "self", ",", "chunkSize", ",", "willMeasureLater", ",", "*", "sinks", ")", ":", "nodes", "=", "[", "None", "]", "height", "=", "1", "def", "sortKey", "(", "node", ")", ":", "if", "node", "is", "None", ":", "return", "None", "return", "(", "node", ".", "intermediate", ",", "self", ".", "_totalSize", "(", "node", ")", ")", "while", "len", "(", "nodes", ")", ">", "0", ":", "logger", ".", "debug", "(", "\"Analyzing %d nodes for height %d...\"", ",", "len", "(", "nodes", ")", ",", "height", ")", "nodes", ".", "sort", "(", "key", "=", "sortKey", ")", "for", "fromNode", "in", "nodes", ":", "if", "self", ".", "_height", "(", "fromNode", ")", ">=", "height", ":", "continue", "if", "fromNode", "is", "not", "None", "and", "fromNode", ".", "diffSize", "is", "None", ":", "continue", "fromVol", "=", "fromNode", ".", "volume", "if", "fromNode", "else", "None", "logger", ".", "debug", "(", "\"Following edges from %s\"", ",", "fromVol", ")", "for", "sink", "in", "sinks", ":", "# logger.debug(", "# \"Listing edges in %s\",", "# sink", "# )", "for", "edge", "in", "sink", ".", "getEdges", "(", "fromVol", ")", ":", "toVol", "=", "edge", ".", "toVol", "# logger.debug(\"Edge: %s\", edge)", "# Skip any edges already in the destination", "if", "sink", "!=", "self", ".", "dest", "and", "self", ".", "dest", ".", "hasEdge", "(", "edge", ")", ":", "continue", "if", "toVol", "in", "self", ".", "nodes", ":", "toNode", "=", "self", ".", "nodes", "[", "toVol", "]", "# Don't transfer any edges we won't need in the destination", "# elif sink != self.dest:", "# logger.debug(\"Won't transfer unnecessary %s\", edge)", "# continue", "else", ":", "toNode", "=", "_Node", "(", "toVol", ",", "True", ")", "self", ".", "nodes", "[", "toVol", "]", "=", "toNode", "logger", ".", "debug", "(", "\"Considering %s\"", ",", "edge", ")", "edgeSize", "=", "edge", ".", "size", "if", "edge", ".", "sizeIsEstimated", ":", "if", "willMeasureLater", ":", "# Slight preference for accurate sizes", "edgeSize", "*=", "1.2", "else", ":", "# Large preference for accurate sizes", "edgeSize", "*=", "2", "newCost", "=", "self", ".", "_cost", "(", "sink", ",", "edgeSize", ",", "fromNode", ",", "height", ")", "if", "toNode", ".", "diff", "is", "None", ":", "oldCost", "=", "None", "else", ":", "oldCost", "=", "self", ".", "_cost", "(", "toNode", ".", "sink", ",", "toNode", ".", "diffSize", ",", "self", ".", "_getNode", "(", "toNode", ".", "previous", ")", ",", "self", ".", "_height", "(", "toNode", ")", ")", "# Don't use a more-expensive path", "if", "oldCost", "is", "not", "None", "and", "oldCost", "<=", "newCost", ":", "continue", "# Don't create circular paths", "if", "self", ".", "_wouldLoop", "(", "fromVol", ",", "toVol", ")", ":", "# logger.debug(\"Ignoring looping edge: %s\", toVol.display(sink))", "continue", "# if measureSize and sink != self.dest and edge.sizeIsEstimated:", "# sink.measureSize(edge, chunkSize)", "# newCost = self._cost(sink, edge.size, fromSize, height)", "# if oldCost is not None and oldCost <= newCost:", "# continue", "logger", ".", "debug", "(", "\"Replacing edge (%s -> %s cost)\\n%s\"", ",", "humanize", "(", "oldCost", ")", ",", "humanize", "(", "newCost", ")", ",", "toNode", ".", "display", "(", "sink", ")", ")", "# logger.debug(\"Cost elements: %s\", dict(", "# sink=str(sink),", "# edgeSize=humanize(edgeSize),", "# fromSize=humanize(fromSize),", "# height=height,", "# ))", "toNode", ".", "diff", "=", "edge", "nodes", "=", "[", "node", "for", "node", "in", "self", ".", "nodes", ".", "values", "(", ")", "if", "self", ".", "_height", "(", "node", ")", "==", "height", "]", "height", "+=", "1", "self", ".", "_prune", "(", ")", "for", "node", "in", "self", ".", "nodes", ".", "values", "(", ")", ":", "node", ".", "height", "=", "self", ".", "_height", "(", "node", ")", "if", "node", ".", "diff", "is", "None", ":", "logger", ".", "error", "(", "\"No source diffs for %s\"", ",", "node", ".", "volume", ".", "display", "(", "sinks", "[", "-", "1", "]", ",", "detail", "=", "\"line\"", ")", ",", ")" ]

[ "Figure", "out", "the", "best", "diffs", "to", "use", "to", "reach", "all", "our", "required", "volumes", "." ]

[ "def", "update", "(", "collection_name", ",", "upsert", ",", "multi", ",", "spec", ",", "doc", ",", "safe", ",", "last_error_args", ",", "check_keys", ",", "opts", ")", ":", "options", "=", "0", "if", "upsert", ":", "options", "+=", "1", "if", "multi", ":", "options", "+=", "2", "data", "=", "_ZERO_32", "data", "+=", "bson", ".", "_make_c_string", "(", "collection_name", ")", "data", "+=", "struct", ".", "pack", "(", "\"<i\"", ",", "options", ")", "data", "+=", "bson", ".", "BSON", ".", "encode", "(", "spec", ",", "False", ",", "opts", ")", "encoded", "=", "bson", ".", "BSON", ".", "encode", "(", "doc", ",", "check_keys", ",", "opts", ")", "data", "+=", "encoded", "if", "safe", ":", "(", "_", ",", "update_message", ")", "=", "__pack_message", "(", "2001", ",", "data", ")", "(", "request_id", ",", "error_message", ",", "_", ")", "=", "__last_error", "(", "collection_name", ",", "last_error_args", ")", "return", "(", "request_id", ",", "update_message", "+", "error_message", ",", "len", "(", "encoded", ")", ")", "else", ":", "(", "request_id", ",", "update_message", ")", "=", "__pack_message", "(", "2001", ",", "data", ")", "return", "(", "request_id", ",", "update_message", ",", "len", "(", "encoded", ")", ")" ]

[ "Get", "an", "**", "update", "**", "message", "." ]

[ "def", "vcenter_credentials_password", "(", "self", ",", "*", "*", "kwargs", ")", ":", "config", "=", "ET", ".", "Element", "(", "\"config\"", ")", "vcenter", "=", "ET", ".", "SubElement", "(", "config", ",", "\"vcenter\"", ",", "xmlns", "=", "\"urn:brocade.com:mgmt:brocade-vswitch\"", ")", "id_key", "=", "ET", ".", "SubElement", "(", "vcenter", ",", "\"id\"", ")", "id_key", ".", "text", "=", "kwargs", ".", "pop", "(", "'id'", ")", "credentials", "=", "ET", ".", "SubElement", "(", "vcenter", ",", "\"credentials\"", ")", "password", "=", "ET", ".", "SubElement", "(", "credentials", ",", "\"password\"", ")", "password", ".", "text", "=", "kwargs", ".", "pop", "(", "'password'", ")", "callback", "=", "kwargs", ".", "pop", "(", "'callback'", ",", "self", ".", "_callback", ")", "return", "callback", "(", "config", ")" ]

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

[ "def", "last_modified", "(", "self", ")", ":", "mtimes", "=", "list", "(", "map", "(", "os", ".", "path", ".", "getmtime", ",", "self", ".", "related_archives", ")", ")", "return", "max", "(", "mtimes", ")", "if", "mtimes", "else", "time", ".", "time", "(", ")" ]

[ "The", "last", "modified", "time", "of", "the", "requirement", "s", "source", "distribution", "archive", "(", "s", ")", "(", "a", "number", ")", "." ]

[ "def", "set_logger", "(", "self", ",", "logger_name", ",", "level", "=", "logging", ".", "INFO", ")", ":", "log", "=", "logging", ".", "getLogger", "(", "logger_name", ")", "log", ".", "setLevel", "(", "level", ")", "ch", "=", "logging", ".", "StreamHandler", "(", "None", ")", "ch", ".", "setLevel", "(", "level", ")", "# create formatter", "if", "level", "==", "logging", ".", "INFO", ":", "formatter", "=", "logging", ".", "Formatter", "(", "InfoFmtString", ")", "else", ":", "formatter", "=", "logging", ".", "Formatter", "(", "DebugFmtString", ")", "# add formatter to ch", "ch", ".", "setFormatter", "(", "formatter", ")", "# add ch to logger", "log", ".", "addHandler", "(", "ch", ")" ]

[ "Convenience", "function", "to", "quickly", "configure", "full", "debug", "output", "to", "go", "to", "the", "console", "." ]

[ "def", "forecast", "(", "self", ",", "parensemble", "=", "None", ")", ":", "if", "parensemble", "is", "None", ":", "parensemble", "=", "self", ".", "parensemble", "self", ".", "logger", ".", "log", "(", "\"evaluating ensemble\"", ")", "failed_runs", ",", "obsensemble", "=", "self", ".", "_calc_obs", "(", "parensemble", ")", "if", "failed_runs", "is", "not", "None", ":", "self", ".", "logger", ".", "warn", "(", "\"dropping failed realizations\"", ")", "parensemble", ".", "loc", "[", "failed_runs", ",", ":", "]", "=", "np", ".", "NaN", "parensemble", "=", "parensemble", ".", "dropna", "(", ")", "obsensemble", ".", "loc", "[", "failed_runs", ",", ":", "]", "=", "np", ".", "NaN", "obsensemble", "=", "obsensemble", ".", "dropna", "(", ")", "self", ".", "logger", ".", "log", "(", "\"evaluating ensemble\"", ")", "return", "obsensemble" ]

[ "for", "the", "enkf", "formulation", "this", "simply", "moves", "the", "ensemble", "forward", "by", "running", "the", "model", "once", "for", "each", "realization" ]

[ "def", "run", "(", "self", ",", "input_dir", ",", "output_file_path", ")", ":", "logging", ".", "info", "(", "'Running defense %s'", ",", "self", ".", "submission_id", ")", "tmp_run_dir", "=", "self", ".", "temp_copy_extracted_submission", "(", ")", "output_dir", "=", "os", ".", "path", ".", "dirname", "(", "output_file_path", ")", "output_filename", "=", "os", ".", "path", ".", "basename", "(", "output_file_path", ")", "cmd", "=", "[", "'--network=none'", ",", "'-m=24g'", ",", "'--cpus=3.75'", ",", "'-v'", ",", "'{0}:/input_images:ro'", ".", "format", "(", "input_dir", ")", ",", "'-v'", ",", "'{0}:/output_data'", ".", "format", "(", "output_dir", ")", ",", "'-v'", ",", "'{0}:/code'", ".", "format", "(", "tmp_run_dir", ")", ",", "'-w'", ",", "'/code'", ",", "self", ".", "container_name", ",", "'./'", "+", "self", ".", "entry_point", ",", "'/input_images'", ",", "'/output_data/'", "+", "output_filename", "]", "elapsed_time_sec", "=", "self", ".", "run_with_time_limit", "(", "cmd", ")", "sudo_remove_dirtree", "(", "tmp_run_dir", ")", "return", "elapsed_time_sec" ]

[ "Runs", "defense", "inside", "Docker", "." ]

[ "def", "serialize_to_rsb", "(", "params", ":", "dict", ")", "->", "bytes", ":", "header", "=", "bytearray", "(", "np", ".", "zeros", "(", "2048", ",", "np", ".", "byte", ")", ".", "tostring", "(", ")", ")", "if", "\"text_header_size\"", "in", "params", ":", "header", "[", "0", ":", "4", "]", "=", "struct", ".", "pack", "(", "'I'", ",", "params", "[", "\"text_header_size\"", "]", ")", "if", "\"events_num\"", "in", "params", ":", "header", "[", "8", ":", "12", "]", "=", "struct", ".", "pack", "(", "'i'", ",", "params", "[", "\"events_num\"", "]", ")", "if", "\"start_time\"", "in", "params", ":", "start_time", "=", "dateutil", ".", "parser", ".", "parse", "(", "params", "[", "\"start_time\"", "]", ")", ".", "timestamp", "(", ")", "header", "[", "16", ":", "24", "]", "=", "struct", ".", "pack", "(", "'Q'", ",", "int", "(", "start_time", ")", ")", "if", "\"end_time\"", "in", "params", ":", "end_time", "=", "dateutil", ".", "parser", ".", "parse", "(", "params", "[", "\"end_time\"", "]", ")", ".", "timestamp", "(", ")", "header", "[", "24", ":", "32", "]", "=", "struct", ".", "pack", "(", "'Q'", ",", "int", "(", "end_time", ")", ")", "header", "[", "32", ":", "32", "+", "len", "(", "params", "[", "\"filepath\"", "]", ")", "]", "=", "params", "[", "'filepath'", "]", ".", "encode", "(", "'cp1251'", ")", "header", "[", "288", ":", "292", "]", "=", "struct", ".", "pack", "(", "'i'", ",", "params", "[", "\"num_blocks\"", "]", ")", "header", "[", "292", ":", "296", "]", "=", "struct", ".", "pack", "(", "'i'", ",", "int", "(", "params", "[", "\"aquisition_time\"", "]", ")", ")", "header", "[", "296", ":", "300", "]", "=", "struct", ".", "pack", "(", "'i'", ",", "params", "[", "\"blocks_in_file\"", "]", ")", "header", "[", "300", ":", "304", "]", "=", "struct", ".", "pack", "(", "'i'", ",", "int", "(", "params", "[", "\"waitTime\"", "]", ")", ")", "header", "[", "312", ":", "320", "]", "=", "struct", ".", "pack", "(", "'d'", ",", "params", "[", "\"threshold\"", "]", ")", "sync_params", "=", "params", "[", "\"synchro_control\"", "]", "sync_params_num", "=", "len", "(", "sync_params", ")", "header", "[", "336", ":", "340", "]", "=", "struct", ".", "pack", "(", "'I'", ",", "sync_params_num", ")", "for", "i", "in", "range", "(", "sync_params_num", ")", ":", "if", "sync_params", "[", "i", "]", "==", "'Default'", ":", "code", "=", "0", "else", ":", "code", "=", "synchro_control", "[", "sync_params", "[", "i", "]", "]", "header", "[", "320", "+", "i", "*", "4", ":", "320", "+", "(", "i", "+", "1", ")", "*", "4", "]", "=", "struct", ".", "pack", "(", "'I'", ",", "code", ")", "header", "[", "344", ":", "352", "]", "=", "struct", ".", "pack", "(", "'d'", ",", "params", "[", "\"sample_freq\"", "]", ")", "header", "[", "352", ":", "356", "]", "=", "struct", ".", "pack", "(", "'I'", ",", "params", "[", "\"pre_history\"", "]", ")", "header", "[", "356", ":", "360", "]", "=", "struct", ".", "pack", "(", "'i'", ",", "params", "[", "\"packet_number\"", "]", ")", "header", "[", "360", ":", "364", "]", "=", "struct", ".", "pack", "(", "'I'", ",", "params", "[", "\"b_size\"", "]", ")", "header", "[", "364", ":", "368", "]", "=", "struct", ".", "pack", "(", "'I'", ",", "params", "[", "\"hysteresis\"", "]", ")", "header", "[", "368", ":", "372", "]", "=", "struct", ".", "pack", "(", "'I'", ",", "params", "[", "\"channel_number\"", "]", ")", "for", "i", "in", "range", "(", "params", "[", "\"channel_number\"", "]", ")", ":", "off", "=", "372", "+", "56", "*", "i", "ch_param", "=", "params", "[", "'channel'", "]", "[", "i", "]", "header", "[", "off", "+", "44", ":", "off", "+", "52", "]", "=", "struct", ".", "pack", "(", "'d'", ",", "ch_param", "[", "\"adjustment\"", "]", ")", "header", "[", "off", "+", "52", ":", "off", "+", "56", "]", "=", "struct", ".", "pack", "(", "'I'", ",", "ch_param", "[", "\"gain\"", "]", ")", "header", "[", "off", "+", "36", ":", "off", "+", "40", "]", "=", "struct", ".", "pack", "(", "'I'", ",", "len", "(", "ch_param", "[", "'params'", "]", ")", ")", "for", "j", ",", "param", "in", "enumerate", "(", "ch_param", "[", "'params'", "]", ")", ":", "if", "param", "==", "'Default'", ":", "code", "=", "0", "else", ":", "code", "=", "channel_control", "[", "param", "]", "header", "[", "off", "+", "4", "+", "j", "*", "4", ":", "off", "+", "4", "+", "(", "j", "+", "1", ")", "*", "4", "]", "=", "struct", ".", "pack", "(", "'I'", ",", "code", ")", "synchro_channel", "=", "params", "[", "'synchro_channel'", "]", "header", "[", "632", ":", "636", "]", "=", "struct", ".", "pack", "(", "'I'", ",", "len", "(", "synchro_channel", "[", "'params'", "]", ")", ")", "for", "i", ",", "param", "in", "enumerate", "(", "synchro_channel", "[", "'params'", "]", ")", ":", "if", "param", "==", "'Default'", ":", "code", "=", "0", "else", ":", "code", "=", "synchro_channel_control", "[", "param", "]", "header", "[", "600", "+", "i", "*", "4", ":", "600", "+", "(", "i", "+", "1", ")", "*", "4", "]", "=", "struct", ".", "pack", "(", "'I'", ",", "code", ")", "sync_type", "=", "synchro_channel_types", "[", "synchro_channel", "[", "'type'", "]", "]", "header", "[", "304", ":", "308", "]", "=", "struct", ".", "pack", "(", "'I'", ",", "sync_type", ")", "header", "[", "636", ":", "640", "]", "=", "struct", ".", "pack", "(", "'I'", ",", "synchro_channel", "[", "\"gain\"", "]", ")", "if", "\"err_lang\"", "in", "params", ":", "header", "[", "640", ":", "644", "]", "=", "struct", ".", "pack", "(", "'I'", ",", "params", "[", "\"err_lang\"", "]", ")", "if", "\"board_name\"", "in", "params", ":", "header", "[", "644", ":", "644", "+", "len", "(", "params", "[", "\"board_name\"", "]", ")", "]", "=", "params", "[", "'board_name'", "]", ".", "encode", "(", "'cp1251'", ")", "if", "\"board_id\"", "in", "params", ":", "header", "[", "900", ":", "904", "]", "=", "struct", ".", "pack", "(", "'I'", ",", "params", "[", "\"board_id\"", "]", ")", "return", "bytes", "(", "header", ")" ]

[ "Сериализация", "JSON", "хедера", "rsb", "." ]

[ "def", "nl_family", "(", "self", ",", "value", ")", ":", "self", ".", "bytearray", "[", "self", ".", "_get_slicers", "(", "0", ")", "]", "=", "bytearray", "(", "c_uint", "(", "value", "or", "0", ")", ")" ]

[ "Family", "setter", "." ]

[ "def", "exception_handler", "(", "self", ",", "can_handle_func", ")", ":", "# type: (Callable[[Input, Exception], bool]) -> Callable", "def", "wrapper", "(", "handle_func", ")", ":", "if", "not", "callable", "(", "can_handle_func", ")", "or", "not", "callable", "(", "handle_func", ")", ":", "raise", "SkillBuilderException", "(", "\"Exception Handler can_handle_func and handle_func input \"", "\"parameters should be callable\"", ")", "class_attributes", "=", "{", "\"can_handle\"", ":", "(", "lambda", "self", ",", "handler_input", ",", "exception", ":", "can_handle_func", "(", "handler_input", ",", "exception", ")", ")", ",", "\"handle\"", ":", "lambda", "self", ",", "handler_input", ",", "exception", ":", "handle_func", "(", "handler_input", ",", "exception", ")", "}", "exception_handler_class", "=", "type", "(", "\"ExceptionHandler{}\"", ".", "format", "(", "handle_func", ".", "__name__", ".", "title", "(", ")", ".", "replace", "(", "\"_\"", ",", "\"\"", ")", ")", ",", "(", "AbstractExceptionHandler", ",", ")", ",", "class_attributes", ")", "self", ".", "add_exception_handler", "(", "exception_handler", "=", "exception_handler_class", "(", ")", ")", "return", "wrapper" ]

[ "Decorator", "that", "can", "be", "used", "to", "add", "exception", "handlers", "easily", "to", "the", "builder", "." ]

[ "def", "print_variables_info", "(", "self", ",", "output_file", "=", "sys", ".", "stdout", ")", ":", "table", "=", "(", "' name | type size \\n'", "+", "'---------+-------------------------\\n'", ")", "for", "name", ",", "var_info", "in", "list", "(", "self", ".", "variables", ".", "items", "(", ")", ")", ":", "table", "+=", "'{:>8} | {:>6} {!s:<10}\\n'", ".", "format", "(", "name", ",", "var_info", "[", "0", "]", ",", "var_info", "[", "1", "]", ")", "print", "(", "prefix_indent", "(", "'variables: '", ",", "table", ")", ",", "file", "=", "output_file", ")" ]

[ "Print", "variables", "information", "in", "human", "readble", "format", "." ]

[ "def", "save_file", "(", "self", ",", "path", ":", "str", ",", "file_id", ":", "int", "=", "None", ",", "file_part", ":", "int", "=", "0", ",", "progress", ":", "callable", "=", "None", ",", "progress_args", ":", "tuple", "=", "(", ")", ")", ":", "part_size", "=", "512", "*", "1024", "file_size", "=", "os", ".", "path", ".", "getsize", "(", "path", ")", "if", "file_size", "==", "0", ":", "raise", "ValueError", "(", "\"File size equals to 0 B\"", ")", "if", "file_size", ">", "1500", "*", "1024", "*", "1024", ":", "raise", "ValueError", "(", "\"Telegram doesn't support uploading files bigger than 1500 MiB\"", ")", "file_total_parts", "=", "int", "(", "math", ".", "ceil", "(", "file_size", "/", "part_size", ")", ")", "is_big", "=", "True", "if", "file_size", ">", "10", "*", "1024", "*", "1024", "else", "False", "is_missing_part", "=", "True", "if", "file_id", "is", "not", "None", "else", "False", "file_id", "=", "file_id", "or", "self", ".", "rnd_id", "(", ")", "md5_sum", "=", "md5", "(", ")", "if", "not", "is_big", "and", "not", "is_missing_part", "else", "None", "session", "=", "Session", "(", "self", ",", "self", ".", "dc_id", ",", "self", ".", "auth_key", ",", "is_media", "=", "True", ")", "session", ".", "start", "(", ")", "try", ":", "with", "open", "(", "path", ",", "\"rb\"", ")", "as", "f", ":", "f", ".", "seek", "(", "part_size", "*", "file_part", ")", "while", "True", ":", "chunk", "=", "f", ".", "read", "(", "part_size", ")", "if", "not", "chunk", ":", "if", "not", "is_big", ":", "md5_sum", "=", "\"\"", ".", "join", "(", "[", "hex", "(", "i", ")", "[", "2", ":", "]", ".", "zfill", "(", "2", ")", "for", "i", "in", "md5_sum", ".", "digest", "(", ")", "]", ")", "break", "for", "_", "in", "range", "(", "3", ")", ":", "if", "is_big", ":", "rpc", "=", "functions", ".", "upload", ".", "SaveBigFilePart", "(", "file_id", "=", "file_id", ",", "file_part", "=", "file_part", ",", "file_total_parts", "=", "file_total_parts", ",", "bytes", "=", "chunk", ")", "else", ":", "rpc", "=", "functions", ".", "upload", ".", "SaveFilePart", "(", "file_id", "=", "file_id", ",", "file_part", "=", "file_part", ",", "bytes", "=", "chunk", ")", "if", "session", ".", "send", "(", "rpc", ")", ":", "break", "else", ":", "raise", "AssertionError", "(", "\"Telegram didn't accept chunk #{} of {}\"", ".", "format", "(", "file_part", ",", "path", ")", ")", "if", "is_missing_part", ":", "return", "if", "not", "is_big", ":", "md5_sum", ".", "update", "(", "chunk", ")", "file_part", "+=", "1", "if", "progress", ":", "progress", "(", "self", ",", "min", "(", "file_part", "*", "part_size", ",", "file_size", ")", ",", "file_size", ",", "*", "progress_args", ")", "except", "Client", ".", "StopTransmission", ":", "raise", "except", "Exception", "as", "e", ":", "log", ".", "error", "(", "e", ",", "exc_info", "=", "True", ")", "else", ":", "if", "is_big", ":", "return", "types", ".", "InputFileBig", "(", "id", "=", "file_id", ",", "parts", "=", "file_total_parts", ",", "name", "=", "os", ".", "path", ".", "basename", "(", "path", ")", ",", ")", "else", ":", "return", "types", ".", "InputFile", "(", "id", "=", "file_id", ",", "parts", "=", "file_total_parts", ",", "name", "=", "os", ".", "path", ".", "basename", "(", "path", ")", ",", "md5_checksum", "=", "md5_sum", ")", "finally", ":", "session", ".", "stop", "(", ")" ]

[ "Use", "this", "method", "to", "upload", "a", "file", "onto", "Telegram", "servers", "without", "actually", "sending", "the", "message", "to", "anyone", "." ]

[ "def", "_acquire_lock", "(", "self", ",", "identifier", ",", "atime", "=", "30", ",", "ltime", "=", "5", ")", ":", "conn", "=", "redis", ".", "Redis", "(", "connection_pool", "=", "self", ".", "pool", ")", "end", "=", "time", ".", "time", "(", ")", "+", "atime", "while", "end", ">", "time", ".", "time", "(", ")", ":", "if", "conn", ".", "set", "(", "self", ".", "_lock_name", ",", "identifier", ",", "ex", "=", "ltime", ",", "nx", "=", "True", ")", ":", "# logger.debug(\"won lock %s\" % self._lock_name)", "return", "identifier", "sleep_time", "=", "random", ".", "uniform", "(", "0", ",", "3", ")", "time", ".", "sleep", "(", "sleep_time", ")", "logger", ".", "warn", "(", "'failed to acquire lock %s for %f seconds'", ",", "self", ".", "_lock_name", ",", "atime", ")", "return", "False" ]

[ "Acquire", "a", "lock", "for", "a", "given", "identifier", "." ]

[ "def", "from_file", "(", "cls", ",", "fmt", ",", "filename", "=", "None", ",", "structure_file", "=", "None", ",", "are_coops", "=", "False", ")", ":", "fmt", "=", "fmt", ".", "upper", "(", ")", "if", "fmt", "==", "\"LMTO\"", ":", "# LMTO COOPs and orbital-resolved COHP cannot be handled yet.", "are_coops", "=", "False", "orb_res_cohp", "=", "None", "if", "structure_file", "is", "None", ":", "structure_file", "=", "\"CTRL\"", "if", "filename", "is", "None", ":", "filename", "=", "\"COPL\"", "cohp_file", "=", "LMTOCopl", "(", "filename", "=", "filename", ",", "to_eV", "=", "True", ")", "elif", "fmt", "==", "\"LOBSTER\"", ":", "if", "structure_file", "is", "None", ":", "structure_file", "=", "\"POSCAR\"", "if", "filename", "is", "None", ":", "filename", "=", "\"COOPCAR.lobster\"", "if", "are_coops", "else", "\"COHPCAR.lobster\"", "warnings", ".", "warn", "(", "\"The bond labels are currently consistent with ICOHPLIST.lobster/ICOOPLIST.lobster, not with COHPCAR.lobster/COOPCAR.lobster. Please be aware!\"", ")", "cohp_file", "=", "Cohpcar", "(", "filename", "=", "filename", ",", "are_coops", "=", "are_coops", ")", "orb_res_cohp", "=", "cohp_file", ".", "orb_res_cohp", "else", ":", "raise", "ValueError", "(", "\"Unknown format %s. Valid formats are LMTO \"", "\"and LOBSTER.\"", "%", "fmt", ")", "structure", "=", "Structure", ".", "from_file", "(", "structure_file", ")", "efermi", "=", "cohp_file", ".", "efermi", "cohp_data", "=", "cohp_file", ".", "cohp_data", "energies", "=", "cohp_file", ".", "energies", "# Lobster shifts the energies so that the Fermi energy is at zero.", "# Shifting should be done by the plotter object though.", "spins", "=", "[", "Spin", ".", "up", ",", "Spin", ".", "down", "]", "if", "cohp_file", ".", "is_spin_polarized", "else", "[", "Spin", ".", "up", "]", "if", "fmt", "==", "\"LOBSTER\"", ":", "energies", "+=", "efermi", "if", "orb_res_cohp", "is", "not", "None", ":", "# If no total COHPs are present, calculate the total", "# COHPs from the single-orbital populations. Total COHPs", "# may not be present when the cohpgenerator keyword is used", "# in LOBSTER versions 2.2.0 and earlier.", "# TODO: Test this more extensively", "for", "label", "in", "orb_res_cohp", ":", "if", "cohp_file", ".", "cohp_data", "[", "label", "]", "[", "\"COHP\"", "]", "is", "None", ":", "# print(label)", "cohp_data", "[", "label", "]", "[", "\"COHP\"", "]", "=", "{", "sp", ":", "np", ".", "sum", "(", "[", "orb_res_cohp", "[", "label", "]", "[", "orbs", "]", "[", "\"COHP\"", "]", "[", "sp", "]", "for", "orbs", "in", "orb_res_cohp", "[", "label", "]", "]", ",", "axis", "=", "0", ")", "for", "sp", "in", "spins", "}", "if", "cohp_file", ".", "cohp_data", "[", "label", "]", "[", "\"ICOHP\"", "]", "is", "None", ":", "cohp_data", "[", "label", "]", "[", "\"ICOHP\"", "]", "=", "{", "sp", ":", "np", ".", "sum", "(", "[", "orb_res_cohp", "[", "label", "]", "[", "orbs", "]", "[", "\"ICOHP\"", "]", "[", "sp", "]", "for", "orbs", "in", "orb_res_cohp", "[", "label", "]", "]", ",", "axis", "=", "0", ")", "for", "sp", "in", "spins", "}", "if", "fmt", "==", "\"LMTO\"", ":", "# Calculate the average COHP for the LMTO file to be", "# consistent with LOBSTER output.", "avg_data", "=", "{", "\"COHP\"", ":", "{", "}", ",", "\"ICOHP\"", ":", "{", "}", "}", "for", "i", "in", "avg_data", ":", "for", "spin", "in", "spins", ":", "rows", "=", "np", ".", "array", "(", "[", "cohp_data", "[", "label", "]", "[", "i", "]", "[", "spin", "]", "for", "label", "in", "cohp_data", "]", ")", "avg", "=", "np", ".", "average", "(", "rows", ",", "axis", "=", "0", ")", "# LMTO COHPs have 5 significant figures", "avg_data", "[", "i", "]", ".", "update", "(", "{", "spin", ":", "np", ".", "array", "(", "[", "round_to_sigfigs", "(", "a", ",", "5", ")", "for", "a", "in", "avg", "]", ",", "dtype", "=", "float", ")", "}", ")", "avg_cohp", "=", "Cohp", "(", "efermi", ",", "energies", ",", "avg_data", "[", "\"COHP\"", "]", ",", "icohp", "=", "avg_data", "[", "\"ICOHP\"", "]", ")", "else", ":", "avg_cohp", "=", "Cohp", "(", "efermi", ",", "energies", ",", "cohp_data", "[", "\"average\"", "]", "[", "\"COHP\"", "]", ",", "icohp", "=", "cohp_data", "[", "\"average\"", "]", "[", "\"COHP\"", "]", ",", "are_coops", "=", "are_coops", ")", "del", "cohp_data", "[", "\"average\"", "]", "cohp_dict", "=", "{", "label", ":", "Cohp", "(", "efermi", ",", "energies", ",", "cohp_data", "[", "label", "]", "[", "\"COHP\"", "]", ",", "icohp", "=", "cohp_data", "[", "label", "]", "[", "\"ICOHP\"", "]", ",", "are_coops", "=", "are_coops", ")", "for", "label", "in", "cohp_data", "}", "bond_dict", "=", "{", "label", ":", "{", "\"length\"", ":", "cohp_data", "[", "label", "]", "[", "\"length\"", "]", ",", "\"sites\"", ":", "[", "structure", ".", "sites", "[", "site", "]", "for", "site", "in", "cohp_data", "[", "label", "]", "[", "\"sites\"", "]", "]", "}", "for", "label", "in", "cohp_data", "}", "return", "CompleteCohp", "(", "structure", ",", "avg_cohp", ",", "cohp_dict", ",", "bonds", "=", "bond_dict", ",", "are_coops", "=", "are_coops", ",", "orb_res_cohp", "=", "orb_res_cohp", ")" ]

[ "Creates", "a", "CompleteCohp", "object", "from", "an", "output", "file", "of", "a", "COHP", "calculation", ".", "Valid", "formats", "are", "either", "LMTO", "(", "for", "the", "Stuttgart", "LMTO", "-", "ASA", "code", ")", "or", "LOBSTER", "(", "for", "the", "LOBSTER", "code", ")", "." ]

[ "def", "rewind_body", "(", "body", ",", "body_pos", ")", ":", "body_seek", "=", "getattr", "(", "body", ",", "'seek'", ",", "None", ")", "if", "body_seek", "is", "not", "None", "and", "isinstance", "(", "body_pos", ",", "integer_types", ")", ":", "try", ":", "body_seek", "(", "body_pos", ")", "except", "(", "IOError", ",", "OSError", ")", ":", "raise", "UnrewindableBodyError", "(", "\"An error occurred when rewinding request \"", "\"body for redirect/retry.\"", ")", "elif", "body_pos", "is", "_FAILEDTELL", ":", "raise", "UnrewindableBodyError", "(", "\"Unable to record file position for rewinding \"", "\"request body during a redirect/retry.\"", ")", "else", ":", "raise", "ValueError", "(", "\"body_pos must be of type integer, \"", "\"instead it was %s.\"", "%", "type", "(", "body_pos", ")", ")" ]

[ "Attempt", "to", "rewind", "body", "to", "a", "certain", "position", ".", "Primarily", "used", "for", "request", "redirects", "and", "retries", "." ]

[ "def", "get_work_item_by_id", "(", "self", ",", "wi_id", ")", ":", "work_items", "=", "self", ".", "get_work_items", "(", "id", "=", "wi_id", ")", "if", "work_items", "is", "not", "None", ":", "return", "work_items", "[", "0", "]", "return", "None" ]

[ "Retrieves", "a", "single", "work", "item", "based", "off", "of", "the", "supplied", "ID" ]

[ "def", "validate_state_locations", "(", "self", ")", ":", "names", "=", "map", "(", "lambda", "loc", ":", "loc", "[", "\"name\"", "]", ",", "self", ".", "locations", ")", "assert", "len", "(", "names", ")", "==", "len", "(", "set", "(", "names", ")", ")", ",", "\"Names of state locations must be unique\"" ]

[ "Names", "of", "all", "state", "locations", "must", "be", "unique", "." ]

[ "def", "get_sendback", "(", "self", ",", "uuid", ",", "key", ")", ":", "def", "send_back_callback", "(", "data", ")", ":", "self", ".", "sendResponse", "(", "serializers", ".", "serialize", "(", "data", ")", ",", "uuid", ",", "key", ")", "return", "send_back_callback" ]

[ "Return", "function", "for", "sending", "progress", "messages", "back", "to", "original", "caller", "." ]

[ "def", "connect", "(", "self", ",", "host", ":", "str", "=", "'127.0.0.1'", ",", "port", ":", "int", "=", "7497", ",", "clientId", ":", "int", "=", "1", ",", "timeout", ":", "float", "=", "2", ")", ":", "return", "self", ".", "_run", "(", "self", ".", "connectAsync", "(", "host", ",", "port", ",", "clientId", ",", "timeout", ")", ")" ]

[ "Connect", "to", "a", "running", "TWS", "or", "IB", "gateway", "application", ".", "After", "the", "connection", "is", "made", "the", "client", "is", "fully", "synchronized", "and", "ready", "to", "serve", "requests", "." ]

[ "def", "save", "(", "self", ",", "path", ")", ":", "(", "folder", ",", "filename", ")", "=", "os", ".", "path", ".", "split", "(", "path", ")", "if", "not", "filename", ":", "filename", "=", "_clean_filename", "(", "self", ".", "name", ")", "path", "=", "os", ".", "path", ".", "join", "(", "folder", ",", "filename", ")", "return", "self", ".", "waveform", ".", "save", "(", "path", ")" ]

[ "Save", "the", "sound", "to", "a", "wave", "file", "at", "the", "given", "path", "." ]

[ "def", "validate", "(", "self", ",", "value", ")", ":", "try", ":", "int_value", "=", "int", "(", "value", ")", "self", ".", "_choice", "=", "int_value", "return", "True", "except", "ValueError", ":", "self", ".", "error_message", "=", "'%s is not a valid integer.'", "%", "value", "return", "False" ]

[ "Return", "True", "if", "the", "choice", "is", "an", "integer", ";", "False", "otherwise", "." ]

[ "def", "require_oauth", "(", "self", ",", "*", "realms", ",", "*", "*", "kwargs", ")", ":", "def", "wrapper", "(", "f", ")", ":", "@", "wraps", "(", "f", ")", "def", "decorated", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "for", "func", "in", "self", ".", "_before_request_funcs", ":", "func", "(", ")", "if", "hasattr", "(", "request", ",", "'oauth'", ")", "and", "request", ".", "oauth", ":", "return", "f", "(", "*", "args", ",", "*", "*", "kwargs", ")", "server", "=", "self", ".", "server", "uri", ",", "http_method", ",", "body", ",", "headers", "=", "extract_params", "(", ")", "try", ":", "valid", ",", "req", "=", "server", ".", "validate_protected_resource_request", "(", "uri", ",", "http_method", ",", "body", ",", "headers", ",", "realms", ")", "except", "Exception", "as", "e", ":", "log", ".", "warn", "(", "'Exception: %r'", ",", "e", ")", "e", ".", "urlencoded", "=", "urlencode", "(", "[", "(", "'error'", ",", "'unknown'", ")", "]", ")", "e", ".", "status_code", "=", "400", "return", "_error_response", "(", "e", ")", "for", "func", "in", "self", ".", "_after_request_funcs", ":", "valid", ",", "req", "=", "func", "(", "valid", ",", "req", ")", "if", "not", "valid", ":", "return", "abort", "(", "401", ")", "# alias user for convenience", "req", ".", "user", "=", "req", ".", "access_token", ".", "user", "request", ".", "oauth", "=", "req", "return", "f", "(", "*", "args", ",", "*", "*", "kwargs", ")", "return", "decorated", "return", "wrapper" ]

[ "Protect", "resource", "with", "specified", "scopes", "." ]

[ "def", "list_alias", "(", ")", ":", "alias_table", "=", "get_alias_table", "(", ")", "output", "=", "[", "]", "for", "alias", "in", "alias_table", ".", "sections", "(", ")", ":", "if", "alias_table", ".", "has_option", "(", "alias", ",", "'command'", ")", ":", "output", ".", "append", "(", "{", "'alias'", ":", "alias", ",", "# Remove unnecessary whitespaces", "'command'", ":", "' '", ".", "join", "(", "alias_table", ".", "get", "(", "alias", ",", "'command'", ")", ".", "split", "(", ")", ")", "}", ")", "return", "output" ]

[ "List", "all", "registered", "aliases", "." ]

[ "def", "calc_lfp_layer", "(", "self", ")", ":", "LFPdict", "=", "{", "}", "lastY", "=", "None", "for", "Y", ",", "y", "in", "self", ".", "mapping_Yy", ":", "if", "lastY", "!=", "Y", ":", "try", ":", "LFPdict", ".", "update", "(", "{", "Y", ":", "self", ".", "LFPdict", "[", "y", "]", "}", ")", "except", "KeyError", ":", "pass", "else", ":", "try", ":", "LFPdict", "[", "Y", "]", "+=", "self", ".", "LFPdict", "[", "y", "]", "except", "KeyError", ":", "pass", "lastY", "=", "Y", "return", "LFPdict" ]

[ "Calculate", "the", "LFP", "from", "concatenated", "subpopulations", "residing", "in", "a", "certain", "layer", "e", ".", "g", "all", "L4E", "pops", "are", "summed", "according", "to", "the", "mapping_Yy", "attribute", "of", "the", "hybridLFPy", ".", "Population", "objects", "." ]

[ "def", "reference", "(", "self", ",", "reference", ")", ":", "if", "reference", "is", "None", ":", "raise", "ValueError", "(", "\"Invalid value for `reference`, must not be `None`\"", ")", "if", "reference", "is", "not", "None", "and", "len", "(", "reference", ")", ">", "50", ":", "raise", "ValueError", "(", "\"Invalid value for `reference`, length must be less than or equal to `50`\"", ")", "if", "reference", "is", "not", "None", "and", "not", "re", ".", "search", "(", "'(?!mbed\\\\.)[\\\\w-_.]{1,50}'", ",", "reference", ")", ":", "raise", "ValueError", "(", "\"Invalid value for `reference`, must be a follow pattern or equal to `/(?!mbed\\\\.)[\\\\w-_.]{1,50}/`\"", ")", "self", ".", "_reference", "=", "reference" ]

[ "Sets", "the", "reference", "of", "this", "CreateCertificateIssuerConfig", ".", "The", "certificate", "name", "as", "created", "in", "the", "factory", "to", "which", "the", "certificate", "issuer", "configuration", "applies", ".", "The", "following", "names", "are", "reserved", "and", "cannot", "be", "configured", ":", "LwM2M", "BOOTSTRAP", "." ]

[ "def", "get_parent_catalog_nodes", "(", "self", ")", ":", "parent_catalog_nodes", "=", "[", "]", "for", "node", "in", "self", ".", "_my_map", "[", "'parentNodes'", "]", ":", "parent_catalog_nodes", ".", "append", "(", "CatalogNode", "(", "node", ".", "_my_map", ",", "runtime", "=", "self", ".", "_runtime", ",", "proxy", "=", "self", ".", "_proxy", ",", "lookup_session", "=", "self", ".", "_lookup_session", ")", ")", "return", "CatalogNodeList", "(", "parent_catalog_nodes", ")" ]

[ "Gets", "the", "parents", "of", "this", "catalog", "." ]

[ "def", "split_at", "(", "iterable", ",", "pred", ")", ":", "buf", "=", "[", "]", "for", "item", "in", "iterable", ":", "if", "pred", "(", "item", ")", ":", "yield", "buf", "buf", "=", "[", "]", "else", ":", "buf", ".", "append", "(", "item", ")", "yield", "buf" ]

[ "Yield", "lists", "of", "items", "from", "*", "iterable", "*", "where", "each", "list", "is", "delimited", "by", "an", "item", "where", "callable", "*", "pred", "*", "returns", "True", ".", "The", "lists", "do", "not", "include", "the", "delimiting", "items", "." ]

[ "def", "vectorize", "(", "self", ",", "token_list", ")", ":", "sentence_list", "=", "[", "token_list", "]", "test_observed_arr", "=", "self", ".", "__setup_dataset", "(", "sentence_list", ",", "self", ".", "__token_master_list", ")", "pred_arr", "=", "self", ".", "__controller", ".", "inference", "(", "test_observed_arr", ")", "return", "self", ".", "__controller", ".", "get_feature_points", "(", ")" ]

[ "Tokenize", "token", "list", ".", "Args", ":", "token_list", ":", "The", "list", "of", "tokens", "..", "Returns", ":", "[", "vector", "of", "token", "vector", "of", "token", "vector", "of", "token", "...", "]" ]

[ "def", "alias_log", "(", "self", ",", "log_id", ",", "alias_id", ")", ":", "# Implemented from template for", "# osid.resource.BinLookupSession.alias_bin_template", "if", "self", ".", "_catalog_session", "is", "not", "None", ":", "return", "self", ".", "_catalog_session", ".", "alias_catalog", "(", "catalog_id", "=", "log_id", ",", "alias_id", "=", "alias_id", ")", "self", ".", "_alias_id", "(", "primary_id", "=", "log_id", ",", "equivalent_id", "=", "alias_id", ")" ]

[ "Adds", "an", "Id", "to", "a", "Log", "for", "the", "purpose", "of", "creating", "compatibility", "." ]

[ "def", "walk_files_relative_path", "(", "self", ",", "relativePath", "=", "\"\"", ")", ":", "def", "walk_files", "(", "directory", ",", "relativePath", ")", ":", "directories", "=", "dict", ".", "__getitem__", "(", "directory", ",", "'directories'", ")", "files", "=", "dict", ".", "__getitem__", "(", "directory", ",", "'files'", ")", "for", "f", "in", "sorted", "(", "files", ")", ":", "yield", "os", ".", "path", ".", "join", "(", "relativePath", ",", "f", ")", "for", "k", "in", "sorted", "(", "dict", ".", "keys", "(", "directories", ")", ")", ":", "path", "=", "os", ".", "path", ".", "join", "(", "relativePath", ",", "k", ")", "dir", "=", "directories", ".", "__getitem__", "(", "k", ")", "for", "e", "in", "walk_files", "(", "dir", ",", "path", ")", ":", "yield", "e", "dir", ",", "errorMessage", "=", "self", ".", "get_directory_info", "(", "relativePath", ")", "assert", "dir", "is", "not", "None", ",", "errorMessage", "return", "walk_files", "(", "dir", ",", "relativePath", "=", "''", ")" ]

[ "Walk", "the", "repository", "and", "yield", "all", "found", "files", "relative", "path", "joined", "with", "file", "name", "." ]

[ "def", "send_margin_order", "(", "self", ",", "acc_id", ",", "amount", ",", "symbol", ",", "_type", ",", "price", "=", "0", ",", "_async", "=", "False", ")", ":", "params", "=", "{", "'account-id'", ":", "acc_id", ",", "'amount'", ":", "amount", ",", "'symbol'", ":", "symbol", ",", "'type'", ":", "_type", ",", "'source'", ":", "'margin-api'", "}", "if", "price", ":", "params", "[", "'price'", "]", "=", "price", "path", "=", "'/v1/order/orders/place'", "return", "api_key_post", "(", "params", ",", "path", ",", "_async", "=", "_async", ")" ]

[ "创建并执行借贷订单", ":", "param", "amount", ":", ":", "param", "symbol", ":", ":", "param", "_type", ":", "可选值", "{", "buy", "-", "market：市价买", "sell", "-", "market：市价卖", "buy", "-", "limit：限价买", "sell", "-", "limit：限价卖", "}", ":", "param", "price", ":", ":", "return", ":" ]

[ "def", "main", "(", "cls", ")", ":", "chain", "=", "cls", ".", "create", "(", ")", "args", "=", "chain", ".", "_run_argparser", "(", "sys", ".", "argv", "[", "1", ":", "]", ")", "chain", ".", "_run_chain", "(", "sys", ".", "stdout", ",", "args", ".", "dry_run", ")", "chain", ".", "_finalize", "(", "args", ".", "dry_run", ")" ]

[ "Hook", "to", "run", "this", "Chain", "from", "the", "command", "line" ]

[ "def", "from_yaml", "(", "cls", ",", "defaults", ",", "*", "*", "kwargs", ")", ":", "# TODO: I hate myself for this. Fix it later mmkay?", "if", "\"token\"", "not", "in", "defaults", ":", "kwargs", "[", "\"token\"", "]", "=", "None", "defaults", "=", "copy", ".", "deepcopy", "(", "defaults", ")", "return", "cls", "(", "defaults", "=", "defaults", ",", "token", "=", "kwargs", ".", "pop", "(", "\"token\"", ")", ",", "directory", "=", "kwargs", ".", "pop", "(", "\"directory\"", ")", ",", "*", "*", "kwargs", ")" ]

[ "Creates", "a", "new", "instance", "of", "a", "rule", "by", "merging", "two", "dictionaries", "." ]

[ "def", "_argsdicts", "(", "args", ",", "mydict", ")", ":", "if", "len", "(", "args", ")", "==", "0", ":", "args", "=", "None", ",", "elif", "len", "(", "args", ")", "==", "1", ":", "args", "=", "_totuple", "(", "args", "[", "0", "]", ")", "else", ":", "raise", "Exception", "(", "\"We should have never gotten here.\"", ")", "mykeys", "=", "list", "(", "mydict", ".", "keys", "(", ")", ")", "myvalues", "=", "list", "(", "map", "(", "_totuple", ",", "list", "(", "mydict", ".", "values", "(", ")", ")", ")", ")", "maxlength", "=", "max", "(", "list", "(", "map", "(", "len", ",", "[", "args", "]", "+", "myvalues", ")", ")", ")", "for", "i", "in", "range", "(", "maxlength", ")", ":", "thisdict", "=", "{", "}", "for", "key", ",", "value", "in", "zip", "(", "mykeys", ",", "myvalues", ")", ":", "try", ":", "thisdict", "[", "key", "]", "=", "value", "[", "i", "]", "except", "IndexError", ":", "thisdict", "[", "key", "]", "=", "value", "[", "-", "1", "]", "try", ":", "thisarg", "=", "args", "[", "i", "]", "except", "IndexError", ":", "thisarg", "=", "args", "[", "-", "1", "]", "yield", "thisarg", ",", "thisdict" ]

[ "A", "utility", "generator", "that", "pads", "argument", "list", "and", "dictionary", "values", "will", "only", "be", "called", "with", "len", "(", "args", ")", "=", "0", "1", "." ]

[ "def", "_get_page_with_optional_heading", "(", "self", ",", "page_file_path", ":", "str", ")", "->", "str", "or", "Dict", ":", "self", ".", "logger", ".", "debug", "(", "f'Looking for the first heading in {page_file_path}'", ")", "if", "page_file_path", ".", "endswith", "(", "'.md'", ")", ":", "page_file_full_path", "=", "self", ".", "project_path", "/", "self", ".", "config", "[", "'src_dir'", "]", "/", "page_file_path", "with", "open", "(", "page_file_full_path", ",", "encoding", "=", "'utf8'", ")", "as", "page_file", ":", "content", "=", "page_file", ".", "read", "(", ")", "headings_found", "=", "search", "(", "r'^\\s*#{1,6}[ \\t]+([^\\r\\n]+?)(?:[ \\t]+\\{#\\S+\\})?\\s*[\\r\\n]+'", ",", "content", ")", "if", "headings_found", ":", "first_heading", "=", "headings_found", ".", "group", "(", "1", ")", "self", ".", "logger", ".", "debug", "(", "f'Heading found: {first_heading}'", ")", "return", "{", "first_heading", ":", "page_file_path", "}", "self", ".", "logger", ".", "debug", "(", "f'No heading found, returning original file path.'", ")", "return", "page_file_path" ]

[ "Get", "the", "content", "of", "first", "heading", "of", "source", "Markdown", "file", "if", "the", "file", "contains", "any", "headings", ".", "Return", "a", "data", "element", "of", "pages", "section", "of", "mkdocs", ".", "yml", "file", "." ]

[ "def", "abbreviate", "(", "labels", ",", "rfill", "=", "' '", ")", ":", "max_len", "=", "max", "(", "len", "(", "l", ")", "for", "l", "in", "labels", ")", "for", "i", "in", "range", "(", "1", ",", "max_len", ")", ":", "abbrev", "=", "[", "l", "[", ":", "i", "]", ".", "ljust", "(", "i", ",", "rfill", ")", "for", "l", "in", "labels", "]", "if", "len", "(", "abbrev", ")", "==", "len", "(", "set", "(", "abbrev", ")", ")", ":", "break", "return", "abbrev" ]

[ "Abbreviate", "labels", "without", "introducing", "ambiguities", "." ]

[ "def", "get_records_for_package", "(", "self", ",", "package_name", ")", ":", "result", "=", "[", "]", "result", ".", "extend", "(", "self", ".", "package_module_map", ".", "get", "(", "package_name", ")", ")", "return", "result" ]

[ "Get", "all", "records", "identified", "by", "package", "." ]

[ "async", "def", "_precache", "(", "url", ",", "to_type", ",", "force", "=", "False", ")", ":", "if", "force", ":", "cli", ".", "print", "(", "'%s: force clearing'", "%", "url", ")", "_clear_cache", "(", "url", ")", "cli", ".", "print", "(", "'%s: precaching \"%s\"'", "%", "(", "url", ",", "to_type", ")", ")", "with", "autodrain_worker", "(", ")", ":", "await", "singletons", ".", "workers", ".", "async_enqueue_multiconvert", "(", "url", ",", "to_type", ")", "result", "=", "TypedResource", "(", "url", ",", "TypeString", "(", "to_type", ")", ")", "cli", ".", "print", "(", "'%s: %s precached at: %s'", "%", "(", "url", ",", "to_type", ",", "result", ".", "cache_path", ")", ")" ]

[ "Helper", "function", "used", "by", "precache", "and", "precache", "-", "named", "which", "does", "the", "actual", "precaching" ]

[ "def", "force_update", "(", "self", ")", ":", "if", "self", ".", "disabled", "or", "self", ".", "terminated", "or", "not", "self", ".", "enabled", ":", "return", "# clear cached_until for each method to allow update", "for", "meth", "in", "self", ".", "methods", ":", "self", ".", "methods", "[", "meth", "]", "[", "\"cached_until\"", "]", "=", "time", "(", ")", "if", "self", ".", "config", "[", "\"debug\"", "]", ":", "self", ".", "_py3_wrapper", ".", "log", "(", "\"clearing cache for method {}\"", ".", "format", "(", "meth", ")", ")", "# set module to update", "self", ".", "_py3_wrapper", ".", "timeout_queue_add", "(", "self", ")" ]

[ "Forces", "an", "update", "of", "the", "module", "." ]

[ "def", "chop", "(", "seq", ",", "size", ")", ":", "chunk", "=", "lambda", "i", ":", "seq", "[", "i", ":", "i", "+", "size", "]", "return", "map", "(", "chunk", ",", "xrange", "(", "0", ",", "len", "(", "seq", ")", ",", "size", ")", ")" ]

[ "Chop", "a", "sequence", "into", "chunks", "of", "the", "given", "size", "." ]

[ "def", "set_mode", "(", "filename", ",", "flags", ")", ":", "try", ":", "mode", "=", "os", ".", "lstat", "(", "filename", ")", ".", "st_mode", "except", "OSError", ":", "# ignore", "return", "if", "not", "(", "mode", "&", "flags", ")", ":", "try", ":", "os", ".", "chmod", "(", "filename", ",", "flags", "|", "mode", ")", "except", "OSError", "as", "msg", ":", "log_error", "(", "\"could not set mode flags for `%s': %s\"", "%", "(", "filename", ",", "msg", ")", ")" ]

[ "Set", "mode", "flags", "for", "given", "filename", "if", "not", "already", "set", "." ]

[ "def", "_read_current_marker", "(", "self", ")", ":", "return", "self", ".", "_geno_values", "[", "np", ".", "frombuffer", "(", "self", ".", "_bed", ".", "read", "(", "self", ".", "_nb_bytes", ")", ",", "dtype", "=", "np", ".", "uint8", ")", "]", ".", "flatten", "(", "order", "=", "\"C\"", ")", "[", ":", "self", ".", "_nb_samples", "]" ]

[ "Reads", "the", "current", "marker", "and", "returns", "its", "genotypes", "." ]

[ "def", "add", "(", "self", ",", "*", "filenodes", ")", ":", "# Check if not already marked as *added* first", "for", "node", "in", "filenodes", ":", "if", "node", ".", "path", "in", "(", "n", ".", "path", "for", "n", "in", "self", ".", "added", ")", ":", "raise", "NodeAlreadyAddedError", "(", "\"Such FileNode %s is already \"", "\"marked for addition\"", "%", "node", ".", "path", ")", "for", "node", "in", "filenodes", ":", "self", ".", "added", ".", "append", "(", "node", ")" ]

[ "Marks", "given", "FileNode", "objects", "as", "*", "to", "be", "committed", "*", "." ]

[ "def", "projected_optimization", "(", "loss_fn", ",", "input_image", ",", "label", ",", "epsilon", ",", "num_steps", ",", "clip_min", "=", "None", ",", "clip_max", "=", "None", ",", "optimizer", "=", "TensorAdam", "(", ")", ",", "project_perturbation", "=", "_project_perturbation", ",", "early_stop_loss_threshold", "=", "None", ",", "is_debug", "=", "False", ")", ":", "assert", "num_steps", "is", "not", "None", "if", "is_debug", ":", "with", "tf", ".", "device", "(", "\"/cpu:0\"", ")", ":", "input_image", "=", "tf", ".", "Print", "(", "input_image", ",", "[", "]", ",", "\"Starting PGD attack with epsilon: %s\"", "%", "epsilon", ")", "init_perturbation", "=", "tf", ".", "random_uniform", "(", "tf", ".", "shape", "(", "input_image", ")", ",", "minval", "=", "tf", ".", "cast", "(", "-", "epsilon", ",", "input_image", ".", "dtype", ")", ",", "maxval", "=", "tf", ".", "cast", "(", "epsilon", ",", "input_image", ".", "dtype", ")", ",", "dtype", "=", "input_image", ".", "dtype", ")", "init_perturbation", "=", "project_perturbation", "(", "init_perturbation", ",", "epsilon", ",", "input_image", ",", "clip_min", "=", "clip_min", ",", "clip_max", "=", "clip_max", ")", "init_optim_state", "=", "optimizer", ".", "init_state", "(", "[", "init_perturbation", "]", ")", "nest", "=", "tf", ".", "contrib", ".", "framework", ".", "nest", "def", "loop_body", "(", "i", ",", "perturbation", ",", "flat_optim_state", ")", ":", "\"\"\"Update perturbation to input image.\"\"\"", "optim_state", "=", "nest", ".", "pack_sequence_as", "(", "structure", "=", "init_optim_state", ",", "flat_sequence", "=", "flat_optim_state", ")", "def", "wrapped_loss_fn", "(", "x", ")", ":", "return", "loss_fn", "(", "input_image", "+", "x", ",", "label", ")", "new_perturbation_list", ",", "new_optim_state", "=", "optimizer", ".", "minimize", "(", "wrapped_loss_fn", ",", "[", "perturbation", "]", ",", "optim_state", ")", "projected_perturbation", "=", "project_perturbation", "(", "new_perturbation_list", "[", "0", "]", ",", "epsilon", ",", "input_image", ",", "clip_min", "=", "clip_min", ",", "clip_max", "=", "clip_max", ")", "# Be careful with this bool. A value of 0. is a valid threshold but evaluates to False, so we must explicitly", "# check whether the value is None.", "early_stop", "=", "early_stop_loss_threshold", "is", "not", "None", "compute_loss", "=", "is_debug", "or", "early_stop", "# Don't waste time building the loss graph if we're not going to use it", "if", "compute_loss", ":", "# NOTE: this step is not actually redundant with the optimizer step.", "# SPSA calculates the loss at randomly perturbed points but doesn't calculate the loss at the current point.", "loss", "=", "reduce_mean", "(", "wrapped_loss_fn", "(", "projected_perturbation", ")", ",", "axis", "=", "0", ")", "if", "is_debug", ":", "with", "tf", ".", "device", "(", "\"/cpu:0\"", ")", ":", "loss", "=", "tf", ".", "Print", "(", "loss", ",", "[", "loss", "]", ",", "\"Total batch loss\"", ")", "if", "early_stop", ":", "i", "=", "tf", ".", "cond", "(", "tf", ".", "less", "(", "loss", ",", "early_stop_loss_threshold", ")", ",", "lambda", ":", "float", "(", "num_steps", ")", ",", "lambda", ":", "i", ")", "return", "i", "+", "1", ",", "projected_perturbation", ",", "nest", ".", "flatten", "(", "new_optim_state", ")", "def", "cond", "(", "i", ",", "*", "_", ")", ":", "return", "tf", ".", "less", "(", "i", ",", "num_steps", ")", "flat_init_optim_state", "=", "nest", ".", "flatten", "(", "init_optim_state", ")", "_", ",", "final_perturbation", ",", "_", "=", "tf", ".", "while_loop", "(", "cond", ",", "loop_body", ",", "loop_vars", "=", "(", "tf", ".", "constant", "(", "0.", ")", ",", "init_perturbation", ",", "flat_init_optim_state", ")", ",", "parallel_iterations", "=", "1", ",", "back_prop", "=", "False", ",", "maximum_iterations", "=", "num_steps", ")", "if", "project_perturbation", "is", "_project_perturbation", ":", "# TODO: this assert looks totally wrong.", "# Not bothering to fix it now because it's only an assert.", "# 1) Multiplying by 1.1 gives a huge margin of error. This should probably", "# take the difference and allow a tolerance of 1e-6 or something like", "# that.", "# 2) I think it should probably check the *absolute value* of", "# final_perturbation", "perturbation_max", "=", "epsilon", "*", "1.1", "check_diff", "=", "utils_tf", ".", "assert_less_equal", "(", "final_perturbation", ",", "tf", ".", "cast", "(", "perturbation_max", ",", "final_perturbation", ".", "dtype", ")", ",", "message", "=", "\"final_perturbation must change no pixel by more than \"", "\"%s\"", "%", "perturbation_max", ")", "else", ":", "# TODO: let caller pass in a check_diff function as well as", "# project_perturbation", "check_diff", "=", "tf", ".", "no_op", "(", ")", "if", "clip_min", "is", "None", "or", "clip_max", "is", "None", ":", "raise", "NotImplementedError", "(", "\"This function only supports clipping for now\"", ")", "check_range", "=", "[", "utils_tf", ".", "assert_less_equal", "(", "input_image", ",", "tf", ".", "cast", "(", "clip_max", ",", "input_image", ".", "dtype", ")", ")", ",", "utils_tf", ".", "assert_greater_equal", "(", "input_image", ",", "tf", ".", "cast", "(", "clip_min", ",", "input_image", ".", "dtype", ")", ")", "]", "with", "tf", ".", "control_dependencies", "(", "[", "check_diff", "]", "+", "check_range", ")", ":", "adversarial_image", "=", "input_image", "+", "final_perturbation", "return", "tf", ".", "stop_gradient", "(", "adversarial_image", ")" ]

[ "Generic", "projected", "optimization", "generalized", "to", "work", "with", "approximate", "gradients", ".", "Used", "for", "e", ".", "g", ".", "the", "SPSA", "attack", "." ]

[ "def", "evaluate_bounding_box", "(", "ctrlpts", ")", ":", "# Estimate dimension from the first element of the control points", "dimension", "=", "len", "(", "ctrlpts", "[", "0", "]", ")", "# Evaluate bounding box", "bbmin", "=", "[", "float", "(", "'inf'", ")", "for", "_", "in", "range", "(", "0", ",", "dimension", ")", "]", "bbmax", "=", "[", "float", "(", "'-inf'", ")", "for", "_", "in", "range", "(", "0", ",", "dimension", ")", "]", "for", "cpt", "in", "ctrlpts", ":", "for", "i", ",", "arr", "in", "enumerate", "(", "zip", "(", "cpt", ",", "bbmin", ")", ")", ":", "if", "arr", "[", "0", "]", "<", "arr", "[", "1", "]", ":", "bbmin", "[", "i", "]", "=", "arr", "[", "0", "]", "for", "i", ",", "arr", "in", "enumerate", "(", "zip", "(", "cpt", ",", "bbmax", ")", ")", ":", "if", "arr", "[", "0", "]", ">", "arr", "[", "1", "]", ":", "bbmax", "[", "i", "]", "=", "arr", "[", "0", "]", "return", "tuple", "(", "bbmin", ")", ",", "tuple", "(", "bbmax", ")" ]

[ "Computes", "the", "minimum", "bounding", "box", "of", "the", "point", "set", "." ]

[ "def", "GenerateBand", "(", "self", ",", "band", ",", "meta_only", "=", "False", ",", "cast", "=", "False", ")", ":", "# Read the band data and add it to dictionary", "if", "not", "meta_only", ":", "fname", "=", "band", ".", "get", "(", "'file_name'", ")", "data", "=", "self", ".", "ReadTif", "(", "'%s/%s'", "%", "(", "os", ".", "path", ".", "dirname", "(", "self", ".", "filename", ")", ",", "fname", ")", ")", "# band['data'] = data # TODO: data is not a properties object so do not set yet", "def", "FixBitmap", "(", "d", ")", ":", "p", "=", "d", ".", "get", "(", "'bitmap_description'", ")", "if", "p", ":", "lis", "=", "p", ".", "get", "(", "'bit'", ")", "bm", "=", "dict", "(", ")", "# Fix bitmap_description from list of dicts to one dict", "for", "i", "in", "lis", ":", "key", "=", "i", "[", "'num'", "]", "value", "=", "i", "[", "'text'", "]", "bm", "[", "key", "]", "=", "value", "del", "d", "[", "'bitmap_description'", "]", "d", "[", "'bitmap_description'", "]", "=", "bm", "return", "d", "band", "=", "SetProperties", "(", "Band", ",", "FixBitmap", "(", "self", ".", "CleanDict", "(", "band", ")", ")", ")", "if", "not", "meta_only", ":", "if", "cast", ":", "# cast as floats and fill bad values with nans", "data", "=", "data", ".", "astype", "(", "np", ".", "float32", ")", "data", "[", "data", "==", "band", ".", "fill_value", "]", "=", "-", "9999", "if", "band", ".", "valid_range", "is", "not", "None", ":", "data", "[", "data", "<", "band", ".", "valid_range", ".", "min", "]", "=", "-", "9999", "data", "[", "data", ">", "band", ".", "valid_range", ".", "max", "]", "=", "-", "9999", "data", "[", "data", "==", "-", "9999", "]", "=", "np", ".", "nan", "else", ":", "data", "=", "np", ".", "ma", ".", "masked_where", "(", "data", "==", "band", ".", "fill_value", ",", "data", ")", "if", "band", ".", "valid_range", "is", "not", "None", ":", "data", "=", "np", ".", "ma", ".", "masked_where", "(", "data", "<", "band", ".", "valid_range", ".", "min", ",", "data", ")", "data", "=", "np", ".", "ma", ".", "masked_where", "(", "data", ">", "band", ".", "valid_range", ".", "max", ",", "data", ")", "# Flip y axis if requested", "if", "self", ".", "yflip", ":", "data", "=", "np", ".", "flip", "(", "data", ",", "0", ")", "band", ".", "data", "=", "data", "if", "not", "meta_only", ":", "band", ".", "validate", "(", ")", "return", "band" ]

[ "Genreate", "a", "Band", "object", "given", "band", "metadata" ]

[ "def", "unravel_run", "(", "res", ",", "save_proposals", "=", "True", ",", "print_progress", "=", "True", ")", ":", "idxs", "=", "res", ".", "samples_id", "# label for each live/dead point", "# Check if we added in the last set of dead points.", "added_live", "=", "True", "try", ":", "if", "len", "(", "idxs", ")", "!=", "(", "res", ".", "niter", "+", "res", ".", "nlive", ")", ":", "added_live", "=", "False", "except", ":", "pass", "# Recreate the nested sampling run for each strand.", "new_res", "=", "[", "]", "nstrands", "=", "len", "(", "np", ".", "unique", "(", "idxs", ")", ")", "for", "counter", ",", "idx", "in", "enumerate", "(", "np", ".", "unique", "(", "idxs", ")", ")", ":", "# Select strand `idx`.", "strand", "=", "(", "idxs", "==", "idx", ")", "nsamps", "=", "sum", "(", "strand", ")", "logl", "=", "res", ".", "logl", "[", "strand", "]", "# Assign log(volume) to samples. With K=1 live point, the expected", "# shrinking in `logvol` at each iteration is `-log(2)` (i.e.", "# shrinking by 1/2). If the final set of live points were added,", "# the expected value of the final live point is a uniform", "# sample and so has an expected value of half the volume", "# of the final dead point.", "if", "added_live", ":", "niter", "=", "nsamps", "-", "1", "logvol_dead", "=", "-", "math", ".", "log", "(", "2", ")", "*", "(", "1.", "+", "np", ".", "arange", "(", "niter", ")", ")", "if", "niter", ">", "0", ":", "logvol_live", "=", "logvol_dead", "[", "-", "1", "]", "+", "math", ".", "log", "(", "0.5", ")", "logvol", "=", "np", ".", "append", "(", "logvol_dead", ",", "logvol_live", ")", "else", ":", "# point always live", "logvol", "=", "np", ".", "array", "(", "[", "math", ".", "log", "(", "0.5", ")", "]", ")", "else", ":", "niter", "=", "nsamps", "logvol", "=", "-", "math", ".", "log", "(", "2", ")", "*", "(", "1.", "+", "np", ".", "arange", "(", "niter", ")", ")", "# Compute weights using quadratic estimator.", "h", "=", "0.", "logz", "=", "-", "1.e300", "loglstar", "=", "-", "1.e300", "logzvar", "=", "0.", "logvols_pad", "=", "np", ".", "concatenate", "(", "(", "[", "0.", "]", ",", "logvol", ")", ")", "logdvols", "=", "misc", ".", "logsumexp", "(", "a", "=", "np", ".", "c_", "[", "logvols_pad", "[", ":", "-", "1", "]", ",", "logvols_pad", "[", "1", ":", "]", "]", ",", "axis", "=", "1", ",", "b", "=", "np", ".", "c_", "[", "np", ".", "ones", "(", "nsamps", ")", ",", "-", "np", ".", "ones", "(", "nsamps", ")", "]", ")", "logdvols", "+=", "math", ".", "log", "(", "0.5", ")", "dlvs", "=", "logvols_pad", "[", ":", "-", "1", "]", "-", "logvols_pad", "[", "1", ":", "]", "saved_logwt", ",", "saved_logz", ",", "saved_logzvar", ",", "saved_h", "=", "[", "]", ",", "[", "]", ",", "[", "]", ",", "[", "]", "for", "i", "in", "range", "(", "nsamps", ")", ":", "loglstar_new", "=", "logl", "[", "i", "]", "logdvol", ",", "dlv", "=", "logdvols", "[", "i", "]", ",", "dlvs", "[", "i", "]", "logwt", "=", "np", ".", "logaddexp", "(", "loglstar_new", ",", "loglstar", ")", "+", "logdvol", "logz_new", "=", "np", ".", "logaddexp", "(", "logz", ",", "logwt", ")", "lzterm", "=", "(", "math", ".", "exp", "(", "loglstar", "-", "logz_new", ")", "*", "loglstar", "+", "math", ".", "exp", "(", "loglstar_new", "-", "logz_new", ")", "*", "loglstar_new", ")", "h_new", "=", "(", "math", ".", "exp", "(", "logdvol", ")", "*", "lzterm", "+", "math", ".", "exp", "(", "logz", "-", "logz_new", ")", "*", "(", "h", "+", "logz", ")", "-", "logz_new", ")", "dh", "=", "h_new", "-", "h", "h", "=", "h_new", "logz", "=", "logz_new", "logzvar", "+=", "dh", "*", "dlv", "loglstar", "=", "loglstar_new", "saved_logwt", ".", "append", "(", "logwt", ")", "saved_logz", ".", "append", "(", "logz", ")", "saved_logzvar", ".", "append", "(", "logzvar", ")", "saved_h", ".", "append", "(", "h", ")", "# Compute sampling efficiency.", "eff", "=", "100.", "*", "nsamps", "/", "sum", "(", "res", ".", "ncall", "[", "strand", "]", ")", "# Save results.", "r", "=", "[", "(", "'nlive'", ",", "1", ")", ",", "(", "'niter'", ",", "niter", ")", ",", "(", "'ncall'", ",", "res", ".", "ncall", "[", "strand", "]", ")", ",", "(", "'eff'", ",", "eff", ")", ",", "(", "'samples'", ",", "res", ".", "samples", "[", "strand", "]", ")", ",", "(", "'samples_id'", ",", "res", ".", "samples_id", "[", "strand", "]", ")", ",", "(", "'samples_it'", ",", "res", ".", "samples_it", "[", "strand", "]", ")", ",", "(", "'samples_u'", ",", "res", ".", "samples_u", "[", "strand", "]", ")", ",", "(", "'logwt'", ",", "np", ".", "array", "(", "saved_logwt", ")", ")", ",", "(", "'logl'", ",", "logl", ")", ",", "(", "'logvol'", ",", "logvol", ")", ",", "(", "'logz'", ",", "np", ".", "array", "(", "saved_logz", ")", ")", ",", "(", "'logzerr'", ",", "np", ".", "sqrt", "(", "np", ".", "array", "(", "saved_logzvar", ")", ")", ")", ",", "(", "'h'", ",", "np", ".", "array", "(", "saved_h", ")", ")", "]", "# Add proposal information (if available).", "if", "save_proposals", ":", "try", ":", "r", ".", "append", "(", "(", "'prop'", ",", "res", ".", "prop", ")", ")", "r", ".", "append", "(", "(", "'prop_iter'", ",", "res", ".", "prop_iter", "[", "strand", "]", ")", ")", "r", ".", "append", "(", "(", "'samples_prop'", ",", "res", ".", "samples_prop", "[", "strand", "]", ")", ")", "r", ".", "append", "(", "(", "'scale'", ",", "res", ".", "scale", "[", "strand", "]", ")", ")", "except", ":", "pass", "# Add on batch information (if available).", "try", ":", "r", ".", "append", "(", "(", "'samples_batch'", ",", "res", ".", "samples_batch", "[", "strand", "]", ")", ")", "r", ".", "append", "(", "(", "'batch_bounds'", ",", "res", ".", "batch_bounds", ")", ")", "except", ":", "pass", "# Append to list of strands.", "new_res", ".", "append", "(", "Results", "(", "r", ")", ")", "# Print progress.", "if", "print_progress", ":", "sys", ".", "stderr", ".", "write", "(", "'\\rStrand: {0}/{1} '", ".", "format", "(", "counter", "+", "1", ",", "nstrands", ")", ")", "return", "new_res" ]

[ "Unravels", "a", "run", "with", "K", "live", "points", "into", "K", "strands", "(", "a", "nested", "sampling", "run", "with", "only", "1", "live", "point", ")", ".", "**", "WARNING", ":", "the", "anciliary", "quantities", "provided", "with", "each", "unraveled", "strand", "are", "only", "valid", "if", "the", "point", "was", "initialized", "from", "the", "prior", ".", "**" ]

[ "def", "set_card_standard", "(", "self", ",", "title", ",", "text", ",", "smallImageUrl", "=", "None", ",", "largeImageUrl", "=", "None", ")", ":", "self", ".", "response", ".", "card", ".", "type", "=", "'Standard'", "self", ".", "response", ".", "card", ".", "title", "=", "title", "self", ".", "response", ".", "card", ".", "text", "=", "text", "if", "smallImageUrl", ":", "self", ".", "response", ".", "card", ".", "image", ".", "smallImageUrl", "=", "smallImageUrl", "if", "largeImageUrl", ":", "self", ".", "response", ".", "card", ".", "image", ".", "largeImageUrl", "=", "largeImageUrl" ]

[ "Set", "response", "card", "as", "standard", "type", "." ]

[ "def", "set_select", "(", "self", ",", "data", ")", ":", "for", "(", "name", ",", "value", ")", "in", "data", ".", "items", "(", ")", ":", "select", "=", "self", ".", "form", ".", "find", "(", "\"select\"", ",", "{", "\"name\"", ":", "name", "}", ")", "if", "not", "select", ":", "raise", "InvalidFormMethod", "(", "\"No select named \"", "+", "name", ")", "# Deselect all options first", "for", "option", "in", "select", ".", "find_all", "(", "\"option\"", ")", ":", "if", "\"selected\"", "in", "option", ".", "attrs", ":", "del", "option", ".", "attrs", "[", "\"selected\"", "]", "# Wrap individual values in a 1-element tuple.", "# If value is a list/tuple, select must be a <select multiple>.", "if", "not", "isinstance", "(", "value", ",", "list", ")", "and", "not", "isinstance", "(", "value", ",", "tuple", ")", ":", "value", "=", "(", "value", ",", ")", "elif", "\"multiple\"", "not", "in", "select", ".", "attrs", ":", "raise", "LinkNotFoundError", "(", "\"Cannot select multiple options!\"", ")", "for", "choice", "in", "value", ":", "option", "=", "select", ".", "find", "(", "\"option\"", ",", "{", "\"value\"", ":", "choice", "}", ")", "# try to find with text instead of value", "if", "not", "option", ":", "option", "=", "select", ".", "find", "(", "\"option\"", ",", "string", "=", "choice", ")", "if", "not", "option", ":", "raise", "LinkNotFoundError", "(", "'Option %s not found for select %s'", "%", "(", "choice", ",", "name", ")", ")", "option", ".", "attrs", "[", "\"selected\"", "]", "=", "\"selected\"" ]

[ "Set", "the", "*", "selected", "*", "-", "attribute", "of", "the", "first", "option", "element", "specified", "by", "data", "(", "i", ".", "e", ".", "select", "an", "option", "from", "a", "dropdown", ")", "." ]

[ "def", "include", "(", "self", ",", "location", ",", "namespace", "=", "None", ",", "app_name", "=", "None", ")", ":", "sorted_entries", "=", "sorted", "(", "self", ".", "routes", ",", "key", "=", "operator", ".", "itemgetter", "(", "0", ")", ",", "reverse", "=", "True", ")", "arg", "=", "[", "u", "for", "_", ",", "u", "in", "sorted_entries", "]", "return", "url", "(", "location", ",", "urls", ".", "include", "(", "arg", "=", "arg", ",", "namespace", "=", "namespace", ",", "app_name", "=", "app_name", ")", ")" ]

[ "Return", "an", "object", "suitable", "for", "url_patterns", "." ]

[ "def", "_input_as_lines", "(", "self", ",", "data", ")", ":", "self", ".", "_input_filename", "=", "self", ".", "getTmpFilename", "(", "self", ".", "WorkingDir", ",", "suffix", "=", "'.fasta'", ")", "with", "open", "(", "self", ".", "_input_filename", ",", "'w'", ")", "as", "f", ":", "# Use lazy iteration instead of list comprehension to", "# prevent reading entire file into memory", "for", "line", "in", "data", ":", "f", ".", "write", "(", "str", "(", "line", ")", ".", "strip", "(", "'\\n'", ")", ")", "f", ".", "write", "(", "'\\n'", ")", "return", "self", ".", "_input_filename" ]

[ "Write", "sequence", "of", "lines", "to", "temp", "file", "return", "filename" ]

[ "def", "local_position_ned_cov_send", "(", "self", ",", "time_boot_ms", ",", "time_utc", ",", "estimator_type", ",", "x", ",", "y", ",", "z", ",", "vx", ",", "vy", ",", "vz", ",", "ax", ",", "ay", ",", "az", ",", "covariance", ",", "force_mavlink1", "=", "False", ")", ":", "return", "self", ".", "send", "(", "self", ".", "local_position_ned_cov_encode", "(", "time_boot_ms", ",", "time_utc", ",", "estimator_type", ",", "x", ",", "y", ",", "z", ",", "vx", ",", "vy", ",", "vz", ",", "ax", ",", "ay", ",", "az", ",", "covariance", ")", ",", "force_mavlink1", "=", "force_mavlink1", ")" ]

[ "The", "filtered", "local", "position", "(", "e", ".", "g", ".", "fused", "computer", "vision", "and", "accelerometers", ")", ".", "Coordinate", "frame", "is", "right", "-", "handed", "Z", "-", "axis", "down", "(", "aeronautical", "frame", "NED", "/", "north", "-", "east", "-", "down", "convention", ")" ]

[ "def", "open_required", "(", "func", ")", ":", "@", "functools", ".", "wraps", "(", "func", ")", "def", "wrapper", "(", "self", ",", "*", "args", ",", "*", "*", "kwargs", ")", ":", "\"\"\"Wrapper function to check that the given ``JLink`` has been\n opened.\n\n Args:\n self (JLink): the ``JLink`` instance\n args: list of arguments to pass to the wrapped function\n kwargs: key-word arguments dict to pass to the wrapped function\n\n Returns:\n The return value of the wrapped function.\n\n Raises:\n JLinkException: if the J-Link DLL is not open or the J-Link is\n disconnected.\n \"\"\"", "if", "not", "self", ".", "opened", "(", ")", ":", "raise", "errors", ".", "JLinkException", "(", "'J-Link DLL is not open.'", ")", "elif", "not", "self", ".", "connected", "(", ")", ":", "raise", "errors", ".", "JLinkException", "(", "'J-Link connection has been lost.'", ")", "return", "func", "(", "self", ",", "*", "args", ",", "*", "*", "kwargs", ")", "return", "wrapper" ]

[ "Decorator", "to", "specify", "that", "the", "J", "-", "Link", "DLL", "must", "be", "opened", "and", "a", "J", "-", "Link", "connection", "must", "be", "established", "." ]

[ "def", "get_anki_phrases_english", "(", "limit", "=", "None", ")", ":", "texts", "=", "set", "(", ")", "for", "lang", "in", "ANKI_LANGUAGES", ":", "df", "=", "get_data", "(", "lang", ")", "phrases", "=", "df", ".", "eng", ".", "str", ".", "strip", "(", ")", ".", "values", "texts", "=", "texts", ".", "union", "(", "set", "(", "phrases", ")", ")", "if", "limit", "and", "len", "(", "texts", ")", ">=", "limit", ":", "break", "return", "sorted", "(", "texts", ")" ]

[ "Return", "all", "the", "English", "phrases", "in", "the", "Anki", "translation", "flashcards" ]

[ "def", "fit_uml", "(", "f", ",", "data", ",", "quiet", "=", "False", ",", "print_level", "=", "0", ",", "*", "arg", ",", "*", "*", "kwd", ")", ":", "uml", "=", "UnbinnedLH", "(", "f", ",", "data", ")", "minuit", "=", "Minuit", "(", "uml", ",", "print_level", "=", "print_level", ",", "*", "*", "kwd", ")", "minuit", ".", "set_strategy", "(", "2", ")", "minuit", ".", "migrad", "(", ")", "if", "not", "minuit", ".", "migrad_ok", "(", ")", "or", "not", "minuit", ".", "matrix_accurate", "(", ")", ":", "if", "not", "quiet", ":", "from", "matplotlib", "import", "pyplot", "as", "plt", "plt", ".", "figure", "(", ")", "uml", ".", "show", "(", ")", "print", "(", "minuit", ".", "values", ")", "return", "(", "uml", ",", "minuit", ")" ]

[ "perform", "unbinned", "likelihood", "fit", ":", "param", "f", ":", "pdf", ":", "param", "data", ":", "data", ":", "param", "quiet", ":", "if", "not", "quite", "draw", "latest", "fit", "on", "fail", "fit", ":", "param", "printlevel", ":", "minuit", "printlevel", ":", "return", ":" ]

[ "def", "getmsg", "(", "option", ",", "lenout", "=", "_default_len_out", ")", ":", "option", "=", "stypes", ".", "stringToCharP", "(", "option", ")", "lenout", "=", "ctypes", ".", "c_int", "(", "lenout", ")", "msg", "=", "stypes", ".", "stringToCharP", "(", "lenout", ")", "libspice", ".", "getmsg_c", "(", "option", ",", "lenout", ",", "msg", ")", "return", "stypes", ".", "toPythonString", "(", "msg", ")" ]

[ "Retrieve", "the", "current", "short", "error", "message", "the", "explanation", "of", "the", "short", "error", "message", "or", "the", "long", "error", "message", "." ]

[ "def", "save_data", "(", "data", ",", "suffix", "=", "''", ",", "dirname", "=", "None", ")", ":", "if", "type", "(", "data", ")", "==", "list", ":", "data", "=", "np", ".", "array", "(", "data", ")", ".", "T", "name", "=", "create_graph_name", "(", "suffix", ",", "dirname", ")", "+", "'.txt'", "np", ".", "savetxt", "(", "name", ",", "data", ")" ]

[ "Save", "a", "dataset", "using", "caller", "s", "name", "." ]

[ "def", "_format_links_fields", "(", "self", ",", "links", ")", ":", "fields", "=", "list", "(", ")", "for", "link", "in", "links", ":", "linked_model", "=", "link", "[", "'mdl'", "]", "(", "super_context", ")", "null", "=", "self", ".", "_marker_true", "if", "link", "[", "'null'", "]", "is", "True", "else", "self", ".", "_marker_false", "# In LinkProxy, if reverse_name is empty then only reverse has the name", "# of the field on the link_source side", "field_name", "=", "link", "[", "'field'", "]", "or", "link", "[", "'reverse'", "]", "fields", ".", "append", "(", "(", "self", ".", "_field_prefix", ",", "field_name", ",", "'%s()'", "%", "linked_model", ".", "title", ",", "null", ")", ")", "fields", ".", "sort", "(", "key", "=", "lambda", "f", ":", "f", "[", "1", "]", ")", "return", "fields" ]

[ "Format", "the", "fields", "containing", "links", "into", "4", "-", "tuples", "printable", "by", "_print_fields", "()", "." ]

[ "def", "detach", "(", "dev", "=", "None", ")", ":", "if", "dev", "is", "None", ":", "res", "=", "{", "}", "for", "dev", ",", "data", "in", "status", "(", "alldevs", "=", "True", ")", ".", "items", "(", ")", ":", "if", "'cache'", "in", "data", ":", "res", "[", "dev", "]", "=", "detach", "(", "dev", ")", "return", "res", "if", "res", "else", "None", "log", ".", "debug", "(", "'Detaching %s'", ",", "dev", ")", "if", "not", "_bcsys", "(", "dev", ",", "'detach'", ",", "'goaway'", ",", "'error'", ",", "'Error detaching {0}'", ".", "format", "(", "dev", ")", ")", ":", "return", "False", "return", "_wait", "(", "lambda", ":", "uuid", "(", "dev", ")", "is", "False", ",", "'error'", ",", "'{0} received detach, but did not comply'", ".", "format", "(", "dev", ")", ",", "300", ")" ]

[ "Detach", "a", "backing", "device", "(", "s", ")", "from", "a", "cache", "set", "If", "no", "dev", "is", "given", "all", "backing", "devices", "will", "be", "attached", "." ]

[ "def", "_is_valid_heading", "(", "self", ")", ":", "elements", "=", "self", ".", "parser", ".", "find", "(", "'h1,h2,h3,h4,h5,h6'", ")", ".", "list_results", "(", ")", "last_level", "=", "0", "count_main_heading", "=", "0", "self", ".", "validate_heading", "=", "True", "for", "element", "in", "elements", ":", "level", "=", "self", ".", "_get_heading_level", "(", "element", ")", "if", "level", "==", "1", ":", "if", "count_main_heading", "==", "1", ":", "return", "False", "else", ":", "count_main_heading", "=", "1", "if", "(", "level", "-", "last_level", ")", ">", "1", ":", "return", "False", "last_level", "=", "level", "return", "True" ]

[ "Check", "that", "the", "headings", "of", "page", "are", "sintatic", "correct", "." ]

[ "def", "respond_to_ask", "(", "self", ",", "message", ")", ":", "valid_actions", ",", "hole_card", ",", "round_state", "=", "self", ".", "__parse_ask_message", "(", "message", ")", "return", "self", ".", "declare_action", "(", "valid_actions", ",", "hole_card", ",", "round_state", ")" ]

[ "Called", "from", "Dealer", "when", "ask", "message", "received", "from", "RoundManager" ]

[ "def", "to_grayscale", "(", "img", ")", ":", "gray", "=", "numpy", ".", "asarray", "(", "ImageOps", ".", "grayscale", "(", "img", ")", ")", ".", "astype", "(", "numpy", ".", "float", ")", "imbands", "=", "img", ".", "getbands", "(", ")", "alpha", "=", "None", "if", "'A'", "in", "imbands", ":", "alpha", "=", "numpy", ".", "asarray", "(", "img", ".", "split", "(", ")", "[", "-", "1", "]", ")", ".", "astype", "(", "numpy", ".", "float", ")", "return", "gray", ",", "alpha" ]

[ "Convert", "PIL", "image", "to", "numpy", "grayscale", "array", "and", "numpy", "alpha", "array", "." ]

[ "def", "fields", "(", "fieldfile", ",", "only_header", "=", "False", ",", "only_istep", "=", "False", ")", ":", "# something to skip header?", "if", "not", "fieldfile", ".", "is_file", "(", ")", ":", "return", "None", "header", "=", "{", "}", "with", "fieldfile", ".", "open", "(", "'rb'", ")", "as", "fid", ":", "readbin", "=", "partial", "(", "_readbin", ",", "fid", ")", "magic", "=", "readbin", "(", ")", "if", "magic", ">", "8000", ":", "# 64 bits", "magic", "-=", "8000", "readbin", "(", ")", "# need to read 4 more bytes", "readbin", "=", "partial", "(", "readbin", ",", "file64", "=", "True", ")", "# check nb components", "nval", "=", "1", "if", "magic", ">", "400", ":", "nval", "=", "4", "elif", "magic", ">", "300", ":", "nval", "=", "3", "magic", "%=", "100", "# extra ghost point in horizontal direction", "header", "[", "'xyp'", "]", "=", "int", "(", "magic", ">=", "9", "and", "nval", "==", "4", ")", "# total number of values in relevant space basis", "# (e1, e2, e3) = (theta, phi, radius) in spherical geometry", "# = (x, y, z) in cartesian geometry", "header", "[", "'nts'", "]", "=", "readbin", "(", "nwords", "=", "3", ")", "# number of blocks, 2 for yinyang or cubed sphere", "header", "[", "'ntb'", "]", "=", "readbin", "(", ")", "if", "magic", ">=", "7", "else", "1", "# aspect ratio", "header", "[", "'aspect'", "]", "=", "readbin", "(", "'f'", ",", "2", ")", "# number of parallel subdomains", "header", "[", "'ncs'", "]", "=", "readbin", "(", "nwords", "=", "3", ")", "# (e1, e2, e3) space", "header", "[", "'ncb'", "]", "=", "readbin", "(", ")", "if", "magic", ">=", "8", "else", "1", "# blocks", "# r - coordinates", "# rgeom[0:self.nrtot+1, 0] are edge radial position", "# rgeom[0:self.nrtot, 1] are cell-center radial position", "if", "magic", ">=", "2", ":", "header", "[", "'rgeom'", "]", "=", "readbin", "(", "'f'", ",", "header", "[", "'nts'", "]", "[", "2", "]", "*", "2", "+", "1", ")", "else", ":", "header", "[", "'rgeom'", "]", "=", "np", ".", "array", "(", "range", "(", "0", ",", "header", "[", "'nts'", "]", "[", "2", "]", "*", "2", "+", "1", ")", ")", "*", "0.5", "/", "header", "[", "'nts'", "]", "[", "2", "]", "header", "[", "'rgeom'", "]", "=", "np", ".", "resize", "(", "header", "[", "'rgeom'", "]", ",", "(", "header", "[", "'nts'", "]", "[", "2", "]", "+", "1", ",", "2", ")", ")", "header", "[", "'rcmb'", "]", "=", "readbin", "(", "'f'", ")", "if", "magic", ">=", "7", "else", "None", "header", "[", "'ti_step'", "]", "=", "readbin", "(", ")", "if", "magic", ">=", "3", "else", "0", "if", "only_istep", ":", "return", "header", "[", "'ti_step'", "]", "header", "[", "'ti_ad'", "]", "=", "readbin", "(", "'f'", ")", "if", "magic", ">=", "3", "else", "0", "header", "[", "'erupta_total'", "]", "=", "readbin", "(", "'f'", ")", "if", "magic", ">=", "5", "else", "0", "header", "[", "'bot_temp'", "]", "=", "readbin", "(", "'f'", ")", "if", "magic", ">=", "6", "else", "1", "if", "magic", ">=", "4", ":", "header", "[", "'e1_coord'", "]", "=", "readbin", "(", "'f'", ",", "header", "[", "'nts'", "]", "[", "0", "]", ")", "header", "[", "'e2_coord'", "]", "=", "readbin", "(", "'f'", ",", "header", "[", "'nts'", "]", "[", "1", "]", ")", "header", "[", "'e3_coord'", "]", "=", "readbin", "(", "'f'", ",", "header", "[", "'nts'", "]", "[", "2", "]", ")", "else", ":", "# could construct them from other info", "raise", "ParsingError", "(", "fieldfile", ",", "'magic >= 4 expected to get grid geometry'", ")", "if", "only_header", ":", "return", "header", "# READ FIELDS", "# number of points in (e1, e2, e3) directions PER CPU", "npc", "=", "header", "[", "'nts'", "]", "//", "header", "[", "'ncs'", "]", "# number of blocks per cpu", "nbk", "=", "header", "[", "'ntb'", "]", "//", "header", "[", "'ncb'", "]", "# number of values per 'read' block", "npi", "=", "(", "npc", "[", "0", "]", "+", "header", "[", "'xyp'", "]", ")", "*", "(", "npc", "[", "1", "]", "+", "header", "[", "'xyp'", "]", ")", "*", "npc", "[", "2", "]", "*", "nbk", "*", "nval", "header", "[", "'scalefac'", "]", "=", "readbin", "(", "'f'", ")", "if", "nval", ">", "1", "else", "1", "flds", "=", "np", ".", "zeros", "(", "(", "nval", ",", "header", "[", "'nts'", "]", "[", "0", "]", "+", "header", "[", "'xyp'", "]", ",", "header", "[", "'nts'", "]", "[", "1", "]", "+", "header", "[", "'xyp'", "]", ",", "header", "[", "'nts'", "]", "[", "2", "]", ",", "header", "[", "'ntb'", "]", ")", ")", "# loop over parallel subdomains", "for", "icpu", "in", "product", "(", "range", "(", "header", "[", "'ncb'", "]", ")", ",", "range", "(", "header", "[", "'ncs'", "]", "[", "2", "]", ")", ",", "range", "(", "header", "[", "'ncs'", "]", "[", "1", "]", ")", ",", "range", "(", "header", "[", "'ncs'", "]", "[", "0", "]", ")", ")", ":", "# read the data for one CPU", "data_cpu", "=", "readbin", "(", "'f'", ",", "npi", ")", "*", "header", "[", "'scalefac'", "]", "# icpu is (icpu block, icpu z, icpu y, icpu x)", "# data from file is transposed to obtained a field", "# array indexed with (x, y, z, block), as in StagYY", "flds", "[", ":", ",", "icpu", "[", "3", "]", "*", "npc", "[", "0", "]", ":", "(", "icpu", "[", "3", "]", "+", "1", ")", "*", "npc", "[", "0", "]", "+", "header", "[", "'xyp'", "]", ",", "# x", "icpu", "[", "2", "]", "*", "npc", "[", "1", "]", ":", "(", "icpu", "[", "2", "]", "+", "1", ")", "*", "npc", "[", "1", "]", "+", "header", "[", "'xyp'", "]", ",", "# y", "icpu", "[", "1", "]", "*", "npc", "[", "2", "]", ":", "(", "icpu", "[", "1", "]", "+", "1", ")", "*", "npc", "[", "2", "]", ",", "# z", "icpu", "[", "0", "]", "*", "nbk", ":", "(", "icpu", "[", "0", "]", "+", "1", ")", "*", "nbk", "# block", "]", "=", "np", ".", "transpose", "(", "data_cpu", ".", "reshape", "(", "(", "nbk", ",", "npc", "[", "2", "]", ",", "npc", "[", "1", "]", "+", "header", "[", "'xyp'", "]", ",", "npc", "[", "0", "]", "+", "header", "[", "'xyp'", "]", ",", "nval", ")", ")", ")", "return", "header", ",", "flds" ]

[ "Extract", "fields", "data", "." ]

[ "def", "get_as_dataframe", "(", "worksheet", ",", "evaluate_formulas", "=", "False", ",", "*", "*", "options", ")", ":", "all_values", "=", "_get_all_values", "(", "worksheet", ",", "evaluate_formulas", ")", "return", "TextParser", "(", "all_values", ",", "*", "*", "options", ")", ".", "read", "(", ")" ]

[ "Returns", "the", "worksheet", "contents", "as", "a", "DataFrame", "." ]

[ "def", "needsquoting", "(", "c", ",", "quotetabs", ",", "header", ")", ":", "if", "c", "in", "' \\t'", ":", "return", "quotetabs", "# if header, we have to escape _ because _ is used to escape space", "if", "c", "==", "'_'", ":", "return", "header", "return", "c", "==", "ESCAPE", "or", "not", "(", "' '", "<=", "c", "<=", "'~'", ")" ]

[ "Decide", "whether", "a", "particular", "character", "needs", "to", "be", "quoted", "." ]

[ "def", "mount_for_path", "(", "path", ",", "client", ")", ":", "backend_data", "=", "client", ".", "list_secret_backends", "(", ")", "[", "'data'", "]", "backends", "=", "[", "mnt", "for", "mnt", "in", "backend_data", ".", "keys", "(", ")", "]", "path_bits", "=", "path", ".", "split", "(", "'/'", ")", "if", "len", "(", "path_bits", ")", "==", "1", ":", "vault_path", "=", "\"%s/\"", "%", "path", "if", "vault_path", "in", "backends", ":", "return", "vault_path", "[", "0", ":", "len", "(", "vault_path", ")", "-", "1", "]", "else", ":", "for", "i", "in", "range", "(", "1", ",", "len", "(", "path_bits", ")", "+", "1", ")", ":", "vault_path", "=", "\"%s/\"", "%", "'/'", ".", "join", "(", "path_bits", "[", "0", ":", "i", "]", ")", "if", "vault_path", "in", "backends", ":", "return", "vault_path", "[", "0", ":", "len", "(", "vault_path", ")", "-", "1", "]", "return", "None" ]

[ "Returns", "the", "mountpoint", "for", "this", "path" ]

[ "def", "get_match", "(", "self", ",", "elem", ")", ":", "for", "m", "in", "self", ".", "matches", ":", "if", "(", "m", ".", "expression", "is", "not", "None", "and", "eval", "(", "m", ".", "expression", ")", "==", "True", ")", "or", "(", "m", ".", "xpath", "is", "not", "None", "and", "len", "(", "elem", ".", "xpath", "(", "m", ".", "xpath", ",", "namespaces", "=", "m", ".", "namespaces", ")", ")", ">", "0", ")", ":", "LOG", ".", "debug", "(", "\"=> match: %r\"", "%", "m", ".", "expression", ")", "return", "m" ]

[ "for", "the", "given", "elem", "return", "the" ]

[ "def", "_loadData", "(", "self", ",", "data", ")", ":", "self", ".", "_data", "=", "data", "self", ".", "codec", "=", "data", ".", "attrib", ".", "get", "(", "'codec'", ")", "self", ".", "codecID", "=", "data", ".", "attrib", ".", "get", "(", "'codecID'", ")", "self", ".", "id", "=", "cast", "(", "int", ",", "data", ".", "attrib", ".", "get", "(", "'id'", ")", ")", "self", ".", "index", "=", "cast", "(", "int", ",", "data", ".", "attrib", ".", "get", "(", "'index'", ",", "'-1'", ")", ")", "self", ".", "language", "=", "data", ".", "attrib", ".", "get", "(", "'language'", ")", "self", ".", "languageCode", "=", "data", ".", "attrib", ".", "get", "(", "'languageCode'", ")", "self", ".", "selected", "=", "cast", "(", "bool", ",", "data", ".", "attrib", ".", "get", "(", "'selected'", ",", "'0'", ")", ")", "self", ".", "streamType", "=", "cast", "(", "int", ",", "data", ".", "attrib", ".", "get", "(", "'streamType'", ")", ")", "self", ".", "type", "=", "cast", "(", "int", ",", "data", ".", "attrib", ".", "get", "(", "'streamType'", ")", ")" ]

[ "Load", "attribute", "values", "from", "Plex", "XML", "response", "." ]

[ "def", "iter_delimiter", "(", "self", ",", "byte_size", "=", "8192", ")", ":", "partial", "=", "u''", "while", "True", ":", "read_chars", "=", "self", ".", "read", "(", "byte_size", ")", "if", "not", "read_chars", ":", "break", "partial", "+=", "read_chars", "lines", "=", "partial", ".", "split", "(", "self", ".", "delimiter", ")", "partial", "=", "lines", ".", "pop", "(", ")", "for", "line", "in", "lines", ":", "yield", "line", "+", "self", ".", "delimiter", "if", "partial", ":", "yield", "partial" ]

[ "Generalization", "of", "the", "default", "iter", "file", "delimited", "by", "\\", "n", ".", "Note", ":", "The", "newline", "string", "can", "be", "arbitrarily", "long", ";", "it", "need", "not", "be", "restricted", "to", "a", "single", "character", ".", "You", "can", "also", "set", "the", "read", "size", "and", "control", "whether", "or", "not", "the", "newline", "string", "is", "left", "on", "the", "end", "of", "the", "iterated", "lines", ".", "Setting", "newline", "to", "\\", "0", "is", "particularly", "good", "for", "use", "with", "an", "input", "file", "created", "with", "something", "like", "os", ".", "popen", "(", "find", "-", "print0", ")", "." ]

[ "def", "get", "(", "self", ",", "timeout", "=", "None", ")", ":", "# type: (float) -> T", "self", ".", "wait", "(", "timeout", ")", "if", "isinstance", "(", "self", ".", "_result", ",", "Exception", ")", ":", "raise", "self", ".", "_result", "return", "self", ".", "_result" ]

[ "Return", "the", "result", "or", "raise", "the", "error", "the", "function", "has", "produced" ]

[ "def", "read", "(", "self", ",", "identifier", ",", "path", ")", ":", "with", "open", "(", "path", ")", "as", "f", ":", "o", "=", "self", ".", "classes", "[", "\"text\"", "]", "(", "urn", "=", "identifier", ",", "resource", "=", "self", ".", "xmlparse", "(", "f", ")", ")", "return", "o" ]

[ "Retrieve", "and", "parse", "a", "text", "given", "an", "identifier" ]

[ "def", "_rdtxt_gos", "(", "self", ",", "ret", ",", "go_file", ")", ":", "if", "not", "os", ".", "path", ".", "exists", "(", "go_file", ")", ":", "raise", "RuntimeError", "(", "\"CAN NOT READ: {FILE}\\n\"", ".", "format", "(", "FILE", "=", "go_file", ")", ")", "goids", "=", "set", "(", ")", "go2color", "=", "{", "}", "with", "open", "(", "go_file", ")", "as", "ifstrm", ":", "for", "line", "in", "ifstrm", ":", "goids_found", "=", "self", ".", "re_goids", ".", "findall", "(", "line", ")", "if", "goids_found", ":", "goids", ".", "update", "(", "goids_found", ")", "colors", "=", "self", ".", "re_color", ".", "findall", "(", "line", ")", "if", "colors", ":", "if", "len", "(", "goids_found", ")", "==", "len", "(", "colors", ")", ":", "for", "goid", ",", "color", "in", "zip", "(", "goids_found", ",", "colors", ")", ":", "go2color", "[", "goid", "]", "=", "color", "else", ":", "print", "(", "\"IGNORING: {L}\"", ".", "format", "(", "L", "=", "line", ")", ",", ")", "self", ".", "_update_ret", "(", "ret", ",", "goids", ",", "go2color", ")" ]

[ "Read", "GO", "IDs", "from", "a", "file", "." ]

[ "def", "get_port_at_point", "(", "self", ",", "vpos", ",", "distance", "=", "10", ",", "exclude", "=", "None", ",", "exclude_port_fun", "=", "None", ")", ":", "# Method had to be inherited, as the base method has a bug:", "# It misses the statement max_dist = d", "v2i", "=", "self", ".", "get_matrix_v2i", "vx", ",", "vy", "=", "vpos", "max_dist", "=", "distance", "port", "=", "None", "glue_pos", "=", "None", "item", "=", "None", "rect", "=", "(", "vx", "-", "distance", ",", "vy", "-", "distance", ",", "distance", "*", "2", ",", "distance", "*", "2", ")", "items", "=", "self", ".", "get_items_in_rectangle", "(", "rect", ",", "reverse", "=", "True", ")", "for", "i", "in", "items", ":", "if", "exclude", "and", "i", "in", "exclude", ":", "continue", "for", "p", "in", "i", ".", "ports", "(", ")", ":", "if", "not", "p", ".", "connectable", ":", "continue", "if", "exclude_port_fun", "and", "exclude_port_fun", "(", "p", ")", ":", "continue", "ix", ",", "iy", "=", "v2i", "(", "i", ")", ".", "transform_point", "(", "vx", ",", "vy", ")", "pg", ",", "d", "=", "p", ".", "glue", "(", "(", "ix", ",", "iy", ")", ")", "if", "d", ">", "max_dist", ":", "continue", "max_dist", "=", "d", "item", "=", "i", "port", "=", "p", "# transform coordinates from connectable item space to view", "# space", "i2v", "=", "self", ".", "get_matrix_i2v", "(", "i", ")", ".", "transform_point", "glue_pos", "=", "i2v", "(", "*", "pg", ")", "return", "item", ",", "port", ",", "glue_pos" ]

[ "Find", "item", "with", "port", "closest", "to", "specified", "position", "." ]

[ "def", "cluster_reset", "(", "self", ",", "*", ",", "hard", "=", "False", ")", ":", "reset", "=", "hard", "and", "b'HARD'", "or", "b'SOFT'", "fut", "=", "self", ".", "execute", "(", "b'CLUSTER'", ",", "b'RESET'", ",", "reset", ")", "return", "wait_ok", "(", "fut", ")" ]

[ "Reset", "a", "Redis", "Cluster", "node", "." ]

[ "def", "divide_chain", "(", "self", ",", "chain", "=", "0", ")", ":", "indexes", "=", "self", ".", "_get_chain", "(", "chain", ")", "con", "=", "ChainConsumer", "(", ")", "for", "index", "in", "indexes", ":", "chain", "=", "self", ".", "chains", "[", "index", "]", "assert", "chain", ".", "walkers", "is", "not", "None", ",", "\"The chain you have selected was not added with any walkers!\"", "num_walkers", "=", "chain", ".", "walkers", "data", "=", "np", ".", "split", "(", "chain", ".", "chain", ",", "num_walkers", ")", "ws", "=", "np", ".", "split", "(", "chain", ".", "weights", ",", "num_walkers", ")", "for", "j", ",", "(", "c", ",", "w", ")", "in", "enumerate", "(", "zip", "(", "data", ",", "ws", ")", ")", ":", "con", ".", "add_chain", "(", "c", ",", "weights", "=", "w", ",", "name", "=", "\"Chain %d\"", "%", "j", ",", "parameters", "=", "chain", ".", "parameters", ")", "return", "con" ]

[ "Returns", "a", "ChainConsumer", "instance", "containing", "all", "the", "walks", "of", "a", "given", "chain", "as", "individual", "chains", "themselves", "." ]

[ "def", "swipe_top", "(", "self", ",", "steps", "=", "10", ",", "*", "args", ",", "*", "*", "selectors", ")", ":", "self", ".", "device", "(", "*", "*", "selectors", ")", ".", "swipe", ".", "up", "(", "steps", "=", "steps", ")" ]

[ "Swipe", "the", "UI", "object", "with", "*", "selectors", "*", "from", "center", "to", "top" ]

[ "def", "dimensions", "(", "self", ")", ":", "_", ",", "_", ",", "width", ",", "height", "=", "self", ".", "_extents", "return", "height", ",", "width" ]

[ "(", "row_count", "col_count", ")", "pair", "describing", "size", "of", "range", "." ]

[ "def", "_produceIt", "(", "self", ",", "segments", ",", "thunk", ")", ":", "if", "not", "self", ".", "prefixURL", ":", "needle", "=", "(", ")", "else", ":", "needle", "=", "tuple", "(", "self", ".", "prefixURL", ".", "split", "(", "'/'", ")", ")", "S", "=", "len", "(", "needle", ")", "if", "segments", "[", ":", "S", "]", "==", "needle", ":", "if", "segments", "==", "JUST_SLASH", ":", "# I *HATE* THE WEB", "subsegments", "=", "segments", "else", ":", "subsegments", "=", "segments", "[", "S", ":", "]", "res", "=", "thunk", "(", ")", "# Even though the URL matched up, sometimes we might still", "# decide to not handle this request (eg, some prerequisite", "# for our function is not met by the store). Allow None", "# to be returned by createResource to indicate this case.", "if", "res", "is", "not", "None", ":", "return", "res", ",", "subsegments" ]

[ "Underlying", "implmeentation", "of", "L", "{", "PrefixURLMixin", ".", "produceResource", "}", "and", "L", "{", "PrefixURLMixin", ".", "sessionlessProduceResource", "}", "." ]

[ "def", "recarrayisin", "(", "X", ",", "Y", ",", "weak", "=", "True", ")", ":", "if", "(", "weak", "and", "set", "(", "X", ".", "dtype", ".", "names", ")", "!=", "set", "(", "Y", ".", "dtype", ".", "names", ")", ")", "or", "(", "not", "weak", "and", "X", ".", "dtype", ".", "names", "!=", "Y", ".", "dtype", ".", "names", ")", ":", "return", "np", ".", "zeros", "(", "(", "len", "(", "X", ")", ",", ")", ",", "bool", ")", "else", ":", "if", "X", ".", "dtype", ".", "names", "!=", "Y", ".", "dtype", ".", "names", ":", "Y", "=", "np", ".", "rec", ".", "fromarrays", "(", "[", "Y", "[", "a", "]", "for", "a", "in", "X", ".", "dtype", ".", "names", "]", ",", "names", "=", "X", ".", "dtype", ".", "names", ")", "NewX", "=", "np", ".", "array", "(", "[", "str", "(", "l", ")", "for", "l", "in", "X", "]", ")", "NewY", "=", "np", ".", "array", "(", "[", "str", "(", "l", ")", "for", "l", "in", "Y", "]", ")", "NewY", ".", "sort", "(", ")", "return", "isin", "(", "NewX", ",", "NewY", ")" ]

[ "Indices", "of", "elements", "in", "a", "numpy", "record", "array", "(", "or", "ndarray", "with", "structured", "dtype", ")", "that", "appear", "in", "another", "." ]

[ "def", "process_npdu", "(", "self", ",", "npdu", ")", ":", "if", "_debug", ":", "RouterToRouterService", ".", "_debug", "(", "\"process_npdu %r\"", ",", "npdu", ")", "# encode the npdu as if it was about to be delivered to the network", "pdu", "=", "PDU", "(", ")", "npdu", ".", "encode", "(", "pdu", ")", "if", "_debug", ":", "RouterToRouterService", ".", "_debug", "(", "\" - pdu: %r\"", ",", "pdu", ")", "# broadcast messages go to everyone", "if", "pdu", ".", "pduDestination", ".", "addrType", "==", "Address", ".", "localBroadcastAddr", ":", "destList", "=", "self", ".", "connections", ".", "keys", "(", ")", "else", ":", "conn", "=", "self", ".", "connections", ".", "get", "(", "pdu", ".", "pduDestination", ",", "None", ")", "if", "not", "conn", ":", "if", "_debug", ":", "RouterToRouterService", ".", "_debug", "(", "\" - not a connected client\"", ")", "# start a connection attempt", "conn", "=", "self", ".", "connect", "(", "pdu", ".", "pduDestination", ")", "if", "not", "conn", ".", "connected", ":", "# keep a reference to this pdu to send after the ack comes back", "conn", ".", "pendingNPDU", ".", "append", "(", "pdu", ")", "return", "destList", "=", "[", "pdu", ".", "pduDestination", "]", "if", "_debug", ":", "RouterToRouterService", ".", "_debug", "(", "\" - destList: %r\"", ",", "destList", ")", "for", "dest", "in", "destList", ":", "# make a router-to-router NPDU", "xpdu", "=", "RouterToRouterNPDU", "(", "pdu", ")", "xpdu", ".", "pduDestination", "=", "dest", "# send it to the multiplexer", "self", ".", "service_request", "(", "xpdu", ")" ]

[ "encode", "NPDUs", "from", "the", "service", "access", "point", "and", "send", "them", "downstream", "." ]

[ "def", "dehydrate", "(", "self", ")", ":", "# Only concerned about very specific attributes", "result", "=", "{", "}", "for", "attr", "in", "self", ".", "attrs", ":", "result", "[", "attr", "]", "=", "getattr", "(", "self", ",", "attr", ")", "return", "result" ]

[ "Return", "a", "dict", "representing", "this", "bucket", "." ]