Datasets:

kejian

/

codesearchnet-py-linelen40-rebalanced200k-v1

like 0

[ "def", "_update_progress", "(", "self", ",", "percentage", ",", "*", "*", "kwargs", ")", ":", "if", "self", ".", "_show_progressbar", ":", "if", "self", ".", "_progressbar", "is", "None", ":", "self", ".", "_initialize_progressbar", "(", ")", "self", ".", "_progressbar", ".", "update", "(", "percentage", "*", "10000", ")", "if", "self", ".", "_progress_callback", "is", "not", "None", ":", "self", ".", "_progress_callback", "(", "percentage", ",", "*", "*", "kwargs", ")" ]

[ "def", "_parse_response", "(", "self", ",", "result_page", ")", ":", "# Sample result_page, single line -> \"OK: 0; Sent queued message ID: 2063619577732703 SMSGlobalMsgID:6171799108850954\"", "resultline", "=", "result_page", ".", "splitlines", "(", ")", "[", "0", "]", "# get result line", "if", "resultline", ".", "startswith", "(", "'ERROR:'", ")", ":", "raise", "Exception", "(", "resultline", ".", "replace", "(", "'ERROR: '", ",", "''", ")", ")", "patt", "=", "re", ".", "compile", "(", "r'^.+?:\\s*(.+?)\\s*;\\s*Sent queued message ID:\\s*(.+?)\\s*SMSGlobalMsgID:(.+?)$'", ",", "re", ".", "IGNORECASE", ")", "m", "=", "patt", ".", "match", "(", "resultline", ")", "if", "m", ":", "return", "(", "m", ".", "group", "(", "1", ")", ",", "m", ".", "group", "(", "2", ")", ",", "m", ".", "group", "(", "3", ")", ")", "return", "None" ]

[ "def", "parse_args", "(", "args", ")", ":", "Log", ".", "info", "(", "\"Input args: %r\"", "%", "args", ")", "parser", "=", "argparse", ".", "ArgumentParser", "(", ")", "parser", ".", "add_argument", "(", "\"--shard\"", ",", "type", "=", "int", ",", "required", "=", "True", ")", "parser", ".", "add_argument", "(", "\"--topology-name\"", ",", "required", "=", "True", ")", "parser", ".", "add_argument", "(", "\"--topology-id\"", ",", "required", "=", "True", ")", "parser", ".", "add_argument", "(", "\"--topology-defn-file\"", ",", "required", "=", "True", ")", "parser", ".", "add_argument", "(", "\"--state-manager-connection\"", ",", "required", "=", "True", ")", "parser", ".", "add_argument", "(", "\"--state-manager-root\"", ",", "required", "=", "True", ")", "parser", ".", "add_argument", "(", "\"--state-manager-config-file\"", ",", "required", "=", "True", ")", "parser", ".", "add_argument", "(", "\"--tmaster-binary\"", ",", "required", "=", "True", ")", "parser", ".", "add_argument", "(", "\"--stmgr-binary\"", ",", "required", "=", "True", ")", "parser", ".", "add_argument", "(", "\"--metrics-manager-classpath\"", ",", "required", "=", "True", ")", "parser", ".", "add_argument", "(", "\"--instance-jvm-opts\"", ",", "required", "=", "True", ")", "parser", ".", "add_argument", "(", "\"--classpath\"", ",", "required", "=", "True", ")", "parser", ".", "add_argument", "(", "\"--master-port\"", ",", "required", "=", "True", ")", "parser", ".", "add_argument", "(", "\"--tmaster-controller-port\"", ",", "required", "=", "True", ")", "parser", ".", "add_argument", "(", "\"--tmaster-stats-port\"", ",", "required", "=", "True", ")", "parser", ".", "add_argument", "(", "\"--heron-internals-config-file\"", ",", "required", "=", "True", ")", "parser", ".", "add_argument", "(", "\"--override-config-file\"", ",", "required", "=", "True", ")", "parser", ".", "add_argument", "(", "\"--component-ram-map\"", ",", "required", "=", "True", ")", "parser", ".", "add_argument", "(", "\"--component-jvm-opts\"", ",", "required", "=", "True", ")", "parser", ".", "add_argument", "(", "\"--pkg-type\"", ",", "required", "=", "True", ")", "parser", ".", "add_argument", "(", "\"--topology-binary-file\"", ",", "required", "=", "True", ")", "parser", ".", "add_argument", "(", "\"--heron-java-home\"", ",", "required", "=", "True", ")", "parser", ".", "add_argument", "(", "\"--shell-port\"", ",", "required", "=", "True", ")", "parser", ".", "add_argument", "(", "\"--heron-shell-binary\"", ",", "required", "=", "True", ")", "parser", ".", "add_argument", "(", "\"--metrics-manager-port\"", ",", "required", "=", "True", ")", "parser", ".", "add_argument", "(", "\"--cluster\"", ",", "required", "=", "True", ")", "parser", ".", "add_argument", "(", "\"--role\"", ",", "required", "=", "True", ")", "parser", ".", "add_argument", "(", "\"--environment\"", ",", "required", "=", "True", ")", "parser", ".", "add_argument", "(", "\"--instance-classpath\"", ",", "required", "=", "True", ")", "parser", ".", "add_argument", "(", "\"--metrics-sinks-config-file\"", ",", "required", "=", "True", ")", "parser", ".", "add_argument", "(", "\"--scheduler-classpath\"", ",", "required", "=", "True", ")", "parser", ".", "add_argument", "(", "\"--scheduler-port\"", ",", "required", "=", "True", ")", "parser", ".", "add_argument", "(", "\"--python-instance-binary\"", ",", "required", "=", "True", ")", "parser", ".", "add_argument", "(", "\"--cpp-instance-binary\"", ",", "required", "=", "True", ")", "parser", ".", "add_argument", "(", "\"--metricscache-manager-classpath\"", ",", "required", "=", "True", ")", "parser", ".", "add_argument", "(", "\"--metricscache-manager-master-port\"", ",", "required", "=", "True", ")", "parser", ".", "add_argument", "(", "\"--metricscache-manager-stats-port\"", ",", "required", "=", "True", ")", "parser", ".", "add_argument", "(", "\"--metricscache-manager-mode\"", ",", "required", "=", "False", ")", "parser", ".", "add_argument", "(", "\"--is-stateful\"", ",", "required", "=", "True", ")", "parser", ".", "add_argument", "(", "\"--checkpoint-manager-classpath\"", ",", "required", "=", "True", ")", "parser", ".", "add_argument", "(", "\"--checkpoint-manager-port\"", ",", "required", "=", "True", ")", "parser", ".", "add_argument", "(", "\"--checkpoint-manager-ram\"", ",", "type", "=", "long", ",", "required", "=", "True", ")", "parser", ".", "add_argument", "(", "\"--stateful-config-file\"", ",", "required", "=", "True", ")", "parser", ".", "add_argument", "(", "\"--health-manager-mode\"", ",", "required", "=", "True", ")", "parser", ".", "add_argument", "(", "\"--health-manager-classpath\"", ",", "required", "=", "True", ")", "parser", ".", "add_argument", "(", "\"--jvm-remote-debugger-ports\"", ",", "required", "=", "False", ",", "help", "=", "\"ports to be used by a remote debugger for JVM instances\"", ")", "parsed_args", ",", "unknown_args", "=", "parser", ".", "parse_known_args", "(", "args", "[", "1", ":", "]", ")", "if", "unknown_args", ":", "Log", ".", "error", "(", "'Unknown argument: %s'", "%", "unknown_args", "[", "0", "]", ")", "parser", ".", "print_help", "(", ")", "sys", ".", "exit", "(", "1", ")", "return", "parsed_args" ]

[ "def", "polygon_to_mask", "(", "coords", ",", "dims", ",", "z", "=", "None", ")", ":", "bounds", "=", "array", "(", "coords", ")", ".", "astype", "(", "'int'", ")", "path", "=", "Path", "(", "bounds", ")", "grid", "=", "meshgrid", "(", "range", "(", "dims", "[", "1", "]", ")", ",", "range", "(", "dims", "[", "0", "]", ")", ")", "grid_flat", "=", "zip", "(", "grid", "[", "0", "]", ".", "ravel", "(", ")", ",", "grid", "[", "1", "]", ".", "ravel", "(", ")", ")", "mask", "=", "path", ".", "contains_points", "(", "grid_flat", ")", ".", "reshape", "(", "dims", "[", "0", ":", "2", "]", ")", ".", "astype", "(", "'int'", ")", "if", "z", "is", "not", "None", ":", "if", "len", "(", "dims", ")", "<", "3", ":", "raise", "Exception", "(", "'Dims must have three-dimensions for embedding z-index'", ")", "if", "z", ">=", "dims", "[", "2", "]", ":", "raise", "Exception", "(", "'Z-index %g exceeds third dimension %g'", "%", "(", "z", ",", "dims", "[", "2", "]", ")", ")", "tmp", "=", "zeros", "(", "dims", ")", "tmp", "[", ":", ",", ":", ",", "z", "]", "=", "mask", "mask", "=", "tmp", "return", "mask" ]

[ "def", "apply_spectral_norm", "(", "x", ")", ":", "weights_shape", "=", "shape_list", "(", "x", ")", "other", ",", "num_filters", "=", "tf", ".", "reduce_prod", "(", "weights_shape", "[", ":", "-", "1", "]", ")", ",", "weights_shape", "[", "-", "1", "]", "# Reshape into a 2-D matrix with outer size num_filters.", "weights_2d", "=", "tf", ".", "reshape", "(", "x", ",", "(", "other", ",", "num_filters", ")", ")", "# v = Wu / ||W u||", "with", "tf", ".", "variable_scope", "(", "\"u\"", ",", "reuse", "=", "tf", ".", "AUTO_REUSE", ")", ":", "u", "=", "tf", ".", "get_variable", "(", "\"u\"", ",", "[", "num_filters", ",", "1", "]", ",", "initializer", "=", "tf", ".", "truncated_normal_initializer", "(", ")", ",", "trainable", "=", "False", ")", "v", "=", "tf", ".", "nn", ".", "l2_normalize", "(", "tf", ".", "matmul", "(", "weights_2d", ",", "u", ")", ")", "# u_new = vW / ||v W||", "u_new", "=", "tf", ".", "nn", ".", "l2_normalize", "(", "tf", ".", "matmul", "(", "tf", ".", "transpose", "(", "v", ")", ",", "weights_2d", ")", ")", "# s = v*W*u", "spectral_norm", "=", "tf", ".", "squeeze", "(", "tf", ".", "matmul", "(", "tf", ".", "transpose", "(", "v", ")", ",", "tf", ".", "matmul", "(", "weights_2d", ",", "tf", ".", "transpose", "(", "u_new", ")", ")", ")", ")", "# set u equal to u_new in the next iteration.", "assign_op", "=", "tf", ".", "assign", "(", "u", ",", "tf", ".", "transpose", "(", "u_new", ")", ")", "return", "tf", ".", "divide", "(", "x", ",", "spectral_norm", ")", ",", "assign_op" ]

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

[ "def", "remove", "(", "id_", ")", ":", "with", "LOCK", ":", "thread", "=", "REGISTRY", ".", "pop", "(", "id_", ",", "None", ")", "if", "thread", "is", "not", "None", ":", "thread", ".", "cancel", "(", ")", "return", "thread" ]

[ "def", "block", "(", "self", ",", "hash", ")", ":", "hash", "=", "self", ".", "_process_value", "(", "hash", ",", "'block'", ")", "payload", "=", "{", "\"hash\"", ":", "hash", "}", "resp", "=", "self", ".", "call", "(", "'block'", ",", "payload", ")", "return", "json", ".", "loads", "(", "resp", "[", "'contents'", "]", ")" ]

[ "def", "_add_addon_views", "(", "self", ")", ":", "for", "addon", "in", "self", ".", "_addon_managers", ":", "addon_class", "=", "dynamic_class_import", "(", "addon", ")", "if", "addon_class", ":", "# Instantiate manager with appbuilder (self)", "addon_class", "=", "addon_class", "(", "self", ")", "try", ":", "addon_class", ".", "pre_process", "(", ")", "addon_class", ".", "register_views", "(", ")", "addon_class", ".", "post_process", "(", ")", "self", ".", "addon_managers", "[", "addon", "]", "=", "addon_class", "log", ".", "info", "(", "LOGMSG_INF_FAB_ADDON_ADDED", ".", "format", "(", "str", "(", "addon", ")", ")", ")", "except", "Exception", "as", "e", ":", "log", ".", "exception", "(", "e", ")", "log", ".", "error", "(", "LOGMSG_ERR_FAB_ADDON_PROCESS", ".", "format", "(", "addon", ",", "e", ")", ")" ]

[ "def", "_updateCallSetIds", "(", "self", ",", "variantFile", ")", ":", "if", "len", "(", "self", ".", "_callSetIdMap", ")", "==", "0", ":", "for", "sample", "in", "variantFile", ".", "header", ".", "samples", ":", "self", ".", "addCallSetFromName", "(", "sample", ")" ]

[ "def", "clear", "(", "self", ")", ":", "self", ".", "_lock", "=", "None", "self", ".", "_ipopo_instance", "=", "None", "self", ".", "_context", "=", "None", "self", ".", "requirement", "=", "None", "self", ".", "_value", "=", "None", "self", ".", "_field", "=", "None" ]

[ "def", "from_xx", "(", "cls", ",", "xx", ")", ":", "xx", "=", "str", "(", "xx", ")", ".", "lower", "(", ")", "if", "xx", "is", "'unknown'", ":", "return", "UnknownLanguage", "(", "xx", ")", "try", ":", "return", "cls", ".", "_from_xyz", "(", "'ISO639'", ",", "xx", ")", "except", "NotALanguageException", ":", "log", ".", "warning", "(", "'Unknown ISO639: {}'", ".", "format", "(", "xx", ")", ")", "return", "UnknownLanguage", "(", "xx", ")" ]

[ "def", "clean_response", "(", "response", ")", ":", "response", "=", "re", ".", "sub", "(", "\"^['\\\"]\"", ",", "\"\"", ",", "response", ")", "response", "=", "re", ".", "sub", "(", "\"['\\\"]$\"", ",", "\"\"", ",", "response", ")", "return", "response" ]

[ "def", "clear_cache", "(", "backend", "=", "None", ")", ":", "fileserver", "=", "salt", ".", "fileserver", ".", "Fileserver", "(", "__opts__", ")", "cleared", ",", "errors", "=", "fileserver", ".", "clear_cache", "(", "back", "=", "backend", ")", "ret", "=", "{", "}", "if", "cleared", ":", "ret", "[", "'cleared'", "]", "=", "cleared", "if", "errors", ":", "ret", "[", "'errors'", "]", "=", "errors", "if", "not", "ret", ":", "return", "'No cache was cleared'", "return", "ret" ]

[ "def", "optimize_skyline", "(", "self", ",", "n_points", "=", "20", ",", "stiffness", "=", "2.0", ",", "method", "=", "'SLSQP'", ",", "tol", "=", "0.03", ",", "regularization", "=", "10.0", ",", "*", "*", "kwarks", ")", ":", "self", ".", "logger", "(", "\"Coalescent:optimize_skyline:... current LH: %f\"", "%", "self", ".", "total_LH", "(", ")", ",", "2", ")", "from", "scipy", ".", "optimize", "import", "minimize", "initial_Tc", "=", "self", ".", "Tc", "tvals", "=", "np", ".", "linspace", "(", "self", ".", "tree_events", "[", "0", ",", "0", "]", ",", "self", ".", "tree_events", "[", "-", "1", ",", "0", "]", ",", "n_points", ")", "def", "cost", "(", "logTc", ")", ":", "# cap log Tc to avoid under or overflow and nan in logs", "self", ".", "set_Tc", "(", "np", ".", "exp", "(", "np", ".", "maximum", "(", "-", "200", ",", "np", ".", "minimum", "(", "100", ",", "logTc", ")", ")", ")", ",", "tvals", ")", "neglogLH", "=", "-", "self", ".", "total_LH", "(", ")", "+", "stiffness", "*", "np", ".", "sum", "(", "np", ".", "diff", "(", "logTc", ")", "**", "2", ")", "+", "np", ".", "sum", "(", "(", "logTc", ">", "0", ")", "*", "logTc", "*", "regularization", ")", "-", "np", ".", "sum", "(", "(", "logTc", "<", "-", "100", ")", "*", "logTc", "*", "regularization", ")", "return", "neglogLH", "sol", "=", "minimize", "(", "cost", ",", "np", ".", "ones_like", "(", "tvals", ")", "*", "np", ".", "log", "(", "self", ".", "Tc", ".", "y", ".", "mean", "(", ")", ")", ",", "method", "=", "method", ",", "tol", "=", "tol", ")", "if", "\"success\"", "in", "sol", "and", "sol", "[", "\"success\"", "]", ":", "dlogTc", "=", "0.1", "opt_logTc", "=", "sol", "[", "'x'", "]", "dcost", "=", "[", "]", "for", "ii", "in", "range", "(", "len", "(", "opt_logTc", ")", ")", ":", "tmp", "=", "opt_logTc", ".", "copy", "(", ")", "tmp", "[", "ii", "]", "+=", "dlogTc", "cost_plus", "=", "cost", "(", "tmp", ")", "tmp", "[", "ii", "]", "-=", "2", "*", "dlogTc", "cost_minus", "=", "cost", "(", "tmp", ")", "dcost", ".", "append", "(", "[", "cost_minus", ",", "cost_plus", "]", ")", "dcost", "=", "np", ".", "array", "(", "dcost", ")", "optimal_cost", "=", "cost", "(", "opt_logTc", ")", "self", ".", "confidence", "=", "-", "dlogTc", "/", "(", "2", "*", "optimal_cost", "-", "dcost", "[", ":", ",", "0", "]", "-", "dcost", "[", ":", ",", "1", "]", ")", "self", ".", "logger", "(", "\"Coalescent:optimize_skyline:...done. new LH: %f\"", "%", "self", ".", "total_LH", "(", ")", ",", "2", ")", "else", ":", "self", ".", "set_Tc", "(", "initial_Tc", ".", "y", ",", "T", "=", "initial_Tc", ".", "x", ")", "self", ".", "logger", "(", "\"Coalescent:optimize_skyline:...failed:\"", "+", "str", "(", "sol", ")", ",", "0", ",", "warn", "=", "True", ")" ]

[ "def", "make_factor", "(", "var", ",", "e", ",", "bn", ")", ":", "node", "=", "bn", ".", "variable_node", "(", "var", ")", "vars", "=", "[", "X", "for", "X", "in", "[", "var", "]", "+", "node", ".", "parents", "if", "X", "not", "in", "e", "]", "cpt", "=", "dict", "(", "(", "event_values", "(", "e1", ",", "vars", ")", ",", "node", ".", "p", "(", "e1", "[", "var", "]", ",", "e1", ")", ")", "for", "e1", "in", "all_events", "(", "vars", ",", "bn", ",", "e", ")", ")", "return", "Factor", "(", "vars", ",", "cpt", ")" ]

[ "def", "delete_user", "(", "self", ",", "username", ",", "params", "=", "None", ")", ":", "if", "username", "in", "SKIP_IN_PATH", ":", "raise", "ValueError", "(", "\"Empty value passed for a required argument 'username'.\"", ")", "return", "self", ".", "transport", ".", "perform_request", "(", "\"DELETE\"", ",", "_make_path", "(", "\"_security\"", ",", "\"user\"", ",", "username", ")", ",", "params", "=", "params", ")" ]

[ "def", "bulk_launch", "(", "self", ",", "jobs", "=", "None", ",", "filter", "=", "None", ",", "all", "=", "False", ")", ":", "# pylint: disable=redefined-builtin", "json", "=", "None", "if", "jobs", "is", "not", "None", ":", "schema", "=", "JobSchema", "(", "exclude", "=", "(", "'id'", ",", "'status'", ",", "'package_name'", ",", "'config_name'", ",", "'device_name'", ",", "'result_id'", ",", "'user_id'", ",", "'created'", ",", "'updated'", ",", "'automatic'", ")", ")", "jobs_json", "=", "self", ".", "service", ".", "encode", "(", "schema", ",", "jobs", ",", "many", "=", "True", ")", "json", "=", "{", "self", ".", "RESOURCE", ":", "jobs_json", "}", "schema", "=", "JobSchema", "(", ")", "resp", "=", "self", ".", "service", ".", "post", "(", "self", ".", "base", ",", "params", "=", "{", "'bulk'", ":", "'launch'", ",", "'filter'", ":", "filter", ",", "'all'", ":", "all", "}", ",", "json", "=", "json", ")", "return", "self", ".", "service", ".", "decode", "(", "schema", ",", "resp", ",", "many", "=", "True", ")" ]

[ "def", "_max_weight_state", "(", "states", ":", "Iterable", "[", "TensorProductState", "]", ")", "->", "Union", "[", "None", ",", "TensorProductState", "]", ":", "mapping", "=", "dict", "(", ")", "# type: Dict[int, _OneQState]", "for", "state", "in", "states", ":", "for", "oneq_state", "in", "state", ".", "states", ":", "if", "oneq_state", ".", "qubit", "in", "mapping", ":", "if", "mapping", "[", "oneq_state", ".", "qubit", "]", "!=", "oneq_state", ":", "return", "None", "else", ":", "mapping", "[", "oneq_state", ".", "qubit", "]", "=", "oneq_state", "return", "TensorProductState", "(", "list", "(", "mapping", ".", "values", "(", ")", ")", ")" ]

[ "def", "_dist_corr", "(", "dist", ",", "phi1", ",", "phi2", ",", "phi3", ")", ":", "return", "phi1", "*", "exp", "(", "-", "phi2", "*", "dist", ")", "+", "(", "1", "-", "phi1", ")", "*", "exp", "(", "-", "phi3", "*", "dist", ")" ]

[ "def", "update_from_delta", "(", "self", ",", "delta", ",", "*", "args", ")", ":", "for", "(", "node", ",", "extant", ")", "in", "delta", ".", "get", "(", "'nodes'", ",", "{", "}", ")", ".", "items", "(", ")", ":", "if", "extant", ":", "if", "node", "in", "delta", ".", "get", "(", "'node_val'", ",", "{", "}", ")", "and", "'location'", "in", "delta", "[", "'node_val'", "]", "[", "node", "]", "and", "node", "not", "in", "self", ".", "pawn", ":", "self", ".", "add_pawn", "(", "node", ")", "elif", "node", "not", "in", "self", ".", "spot", ":", "self", ".", "add_spot", "(", "node", ")", "spot", "=", "self", ".", "spot", "[", "node", "]", "if", "'_x'", "not", "in", "spot", ".", "place", "or", "'_y'", "not", "in", "spot", ".", "place", ":", "self", ".", "spots_unposd", ".", "append", "(", "spot", ")", "else", ":", "if", "node", "in", "self", ".", "pawn", ":", "self", ".", "rm_pawn", "(", "node", ")", "if", "node", "in", "self", ".", "spot", ":", "self", ".", "rm_spot", "(", "node", ")", "for", "(", "node", ",", "stats", ")", "in", "delta", ".", "get", "(", "'node_val'", ",", "{", "}", ")", ".", "items", "(", ")", ":", "if", "node", "in", "self", ".", "spot", ":", "spot", "=", "self", ".", "spot", "[", "node", "]", "x", "=", "stats", ".", "get", "(", "'_x'", ")", "y", "=", "stats", ".", "get", "(", "'_y'", ")", "if", "x", "is", "not", "None", ":", "spot", ".", "x", "=", "x", "*", "self", ".", "width", "if", "y", "is", "not", "None", ":", "spot", ".", "y", "=", "y", "*", "self", ".", "height", "if", "'_image_paths'", "in", "stats", ":", "spot", ".", "paths", "=", "stats", "[", "'_image_paths'", "]", "or", "spot", ".", "default_image_paths", "elif", "node", "in", "self", ".", "pawn", ":", "pawn", "=", "self", ".", "pawn", "[", "node", "]", "if", "'location'", "in", "stats", ":", "pawn", ".", "loc_name", "=", "stats", "[", "'location'", "]", "if", "'_image_paths'", "in", "stats", ":", "pawn", ".", "paths", "=", "stats", "[", "'_image_paths'", "]", "or", "pawn", ".", "default_image_paths", "else", ":", "Logger", ".", "warning", "(", "\"Board: diff tried to change stats of node {} \"", "\"but I don't have a widget for it\"", ".", "format", "(", "node", ")", ")", "for", "(", "orig", ",", "dests", ")", "in", "delta", ".", "get", "(", "'edges'", ",", "{", "}", ")", ".", "items", "(", ")", ":", "for", "(", "dest", ",", "extant", ")", "in", "dests", ".", "items", "(", ")", ":", "if", "extant", "and", "(", "orig", "not", "in", "self", ".", "arrow", "or", "dest", "not", "in", "self", ".", "arrow", "[", "orig", "]", ")", ":", "self", ".", "add_arrow", "(", "orig", ",", "dest", ")", "elif", "not", "extant", "and", "orig", "in", "self", ".", "arrow", "and", "dest", "in", "self", ".", "arrow", "[", "orig", "]", ":", "self", ".", "rm_arrow", "(", "orig", ",", "dest", ")" ]

[ "def", "_generate_ndarray_function_code", "(", "handle", ",", "name", ",", "func_name", ",", "signature_only", "=", "False", ")", ":", "real_name", "=", "ctypes", ".", "c_char_p", "(", ")", "desc", "=", "ctypes", ".", "c_char_p", "(", ")", "num_args", "=", "mx_uint", "(", ")", "arg_names", "=", "ctypes", ".", "POINTER", "(", "ctypes", ".", "c_char_p", ")", "(", ")", "arg_types", "=", "ctypes", ".", "POINTER", "(", "ctypes", ".", "c_char_p", ")", "(", ")", "arg_descs", "=", "ctypes", ".", "POINTER", "(", "ctypes", ".", "c_char_p", ")", "(", ")", "key_var_num_args", "=", "ctypes", ".", "c_char_p", "(", ")", "ret_type", "=", "ctypes", ".", "c_char_p", "(", ")", "check_call", "(", "_LIB", ".", "MXSymbolGetAtomicSymbolInfo", "(", "handle", ",", "ctypes", ".", "byref", "(", "real_name", ")", ",", "ctypes", ".", "byref", "(", "desc", ")", ",", "ctypes", ".", "byref", "(", "num_args", ")", ",", "ctypes", ".", "byref", "(", "arg_names", ")", ",", "ctypes", ".", "byref", "(", "arg_types", ")", ",", "ctypes", ".", "byref", "(", "arg_descs", ")", ",", "ctypes", ".", "byref", "(", "key_var_num_args", ")", ",", "ctypes", ".", "byref", "(", "ret_type", ")", ")", ")", "narg", "=", "int", "(", "num_args", ".", "value", ")", "arg_names", "=", "[", "py_str", "(", "arg_names", "[", "i", "]", ")", "for", "i", "in", "range", "(", "narg", ")", "]", "arg_types", "=", "[", "py_str", "(", "arg_types", "[", "i", "]", ")", "for", "i", "in", "range", "(", "narg", ")", "]", "key_var_num_args", "=", "py_str", "(", "key_var_num_args", ".", "value", ")", "ret_type", "=", "py_str", "(", "ret_type", ".", "value", ")", "if", "ret_type", ".", "value", "is", "not", "None", "else", "''", "doc_str", "=", "_build_doc", "(", "name", ",", "py_str", "(", "desc", ".", "value", ")", ",", "arg_names", ",", "arg_types", ",", "[", "py_str", "(", "arg_descs", "[", "i", "]", ")", "for", "i", "in", "range", "(", "narg", ")", "]", ",", "key_var_num_args", ",", "ret_type", ")", "dtype_name", "=", "None", "arr_name", "=", "None", "ndsignature", "=", "[", "]", "signature", "=", "[", "]", "ndarg_names", "=", "[", "]", "kwarg_names", "=", "[", "]", "for", "i", "in", "range", "(", "narg", ")", ":", "name", ",", "atype", "=", "arg_names", "[", "i", "]", ",", "arg_types", "[", "i", "]", "if", "name", "==", "'dtype'", ":", "dtype_name", "=", "name", "signature", ".", "append", "(", "'%s=_Null'", "%", "name", ")", "elif", "atype", ".", "startswith", "(", "'NDArray'", ")", "or", "atype", ".", "startswith", "(", "'Symbol'", ")", ":", "assert", "not", "arr_name", ",", "\"Op can only have one argument with variable \"", "\"size and it must be the last argument.\"", "if", "atype", ".", "endswith", "(", "'[]'", ")", ":", "ndsignature", ".", "append", "(", "'*%s'", "%", "name", ")", "arr_name", "=", "name", "else", ":", "ndsignature", ".", "append", "(", "'%s=None'", "%", "name", ")", "ndarg_names", ".", "append", "(", "name", ")", "else", ":", "signature", ".", "append", "(", "'%s=_Null'", "%", "name", ")", "kwarg_names", ".", "append", "(", "name", ")", "signature", ".", "append", "(", "'out=None'", ")", "signature", ".", "append", "(", "'name=None'", ")", "signature", ".", "append", "(", "'**kwargs'", ")", "signature", "=", "ndsignature", "+", "signature", "code", "=", "[", "]", "if", "arr_name", ":", "code", ".", "append", "(", "\"\"\"\ndef %s(*%s, **kwargs):\"\"\"", "%", "(", "func_name", ",", "arr_name", ")", ")", "if", "not", "signature_only", ":", "code", ".", "append", "(", "\"\"\"\n ndargs = []\n for i in {}:\n assert isinstance(i, NDArrayBase), \\\\\n \"Positional arguments must have NDArray type, \" \\\\\n \"but got %s\"%str(i)\n ndargs.append(i)\"\"\"", ".", "format", "(", "arr_name", ")", ")", "if", "dtype_name", "is", "not", "None", ":", "code", ".", "append", "(", "\"\"\"\n if '%s' in kwargs:\n kwargs['%s'] = _np.dtype(kwargs['%s']).name\"\"\"", "%", "(", "dtype_name", ",", "dtype_name", ",", "dtype_name", ")", ")", "code", ".", "append", "(", "\"\"\"\n _ = kwargs.pop('name', None)\n out = kwargs.pop('out', None)\n keys = list(kwargs.keys())\n vals = list(kwargs.values())\"\"\"", ")", "else", ":", "code", ".", "append", "(", "\"\"\"\ndef %s(%s):\"\"\"", "%", "(", "func_name", ",", "', '", ".", "join", "(", "signature", ")", ")", ")", "if", "not", "signature_only", ":", "code", ".", "append", "(", "\"\"\"\n ndargs = []\n keys = list(kwargs.keys())\n vals = list(kwargs.values())\"\"\"", ")", "# NDArray args", "for", "name", "in", "ndarg_names", ":", "# pylint: disable=redefined-argument-from-local", "code", ".", "append", "(", "\"\"\"\n if {name} is not None:\n assert isinstance({name}, NDArrayBase), \\\\\n \"Argument {name} must have NDArray type, but got %s\"%str({name})\n ndargs.append({name})\"\"\"", ".", "format", "(", "name", "=", "name", ")", ")", "# kwargs", "for", "name", "in", "kwarg_names", ":", "# pylint: disable=redefined-argument-from-local", "code", ".", "append", "(", "\"\"\"\n if %s is not _Null:\n keys.append('%s')\n vals.append(%s)\"\"\"", "%", "(", "name", ",", "name", ",", "name", ")", ")", "# dtype", "if", "dtype_name", "is", "not", "None", ":", "code", ".", "append", "(", "\"\"\"\n if %s is not _Null:\n keys.append('%s')\n vals.append(_np.dtype(%s).name)\"\"\"", "%", "(", "dtype_name", ",", "dtype_name", ",", "dtype_name", ")", ")", "if", "not", "signature_only", ":", "code", ".", "append", "(", "\"\"\"\n return _imperative_invoke(%d, ndargs, keys, vals, out)\"\"\"", "%", "(", "handle", ".", "value", ")", ")", "else", ":", "code", ".", "append", "(", "\"\"\"\n return (0,)\"\"\"", ")", "doc_str_lines", "=", "_os", ".", "linesep", "+", "''", ".", "join", "(", "[", "' '", "+", "s", "if", "s", ".", "strip", "(", ")", "else", "s", "for", "s", "in", "'r\"\"\"{doc_str}\"\"\"'", ".", "format", "(", "doc_str", "=", "doc_str", ")", ".", "splitlines", "(", "True", ")", "]", ")", "code", ".", "insert", "(", "1", ",", "doc_str_lines", ")", "return", "''", ".", "join", "(", "code", ")", ",", "doc_str" ]

[ "async", "def", "create_signing_key", "(", "self", ",", "seed", ":", "str", "=", "None", ",", "metadata", ":", "dict", "=", "None", ")", "->", "KeyInfo", ":", "LOGGER", ".", "debug", "(", "'Wallet.create_signing_key >>> seed: [SEED], metadata: %s'", ",", "metadata", ")", "if", "not", "self", ".", "handle", ":", "LOGGER", ".", "debug", "(", "'Wallet.create_signing_key <!< Wallet %s is closed'", ",", "self", ".", "name", ")", "raise", "WalletState", "(", "'Wallet {} is closed'", ".", "format", "(", "self", ".", "name", ")", ")", "try", ":", "verkey", "=", "await", "crypto", ".", "create_key", "(", "self", ".", "handle", ",", "json", ".", "dumps", "(", "{", "'seed'", ":", "seed", "}", "if", "seed", "else", "{", "}", ")", ")", "except", "IndyError", "as", "x_indy", ":", "if", "x_indy", ".", "error_code", "==", "ErrorCode", ".", "WalletItemAlreadyExists", ":", "LOGGER", ".", "debug", "(", "'Wallet.create_signing_key <!< Verification key already present in wallet %s'", ",", "self", ".", "name", ")", "raise", "ExtantRecord", "(", "'Verification key already present in wallet {}'", ".", "format", "(", "self", ".", "name", ")", ")", "LOGGER", ".", "debug", "(", "'Wallet.create_signing_key <!< indy-sdk raised error %s'", ",", "x_indy", ".", "error_code", ")", "raise", "await", "crypto", ".", "set_key_metadata", "(", "self", ".", "handle", ",", "verkey", ",", "json", ".", "dumps", "(", "metadata", "or", "{", "}", ")", ")", "# coerce None to empty", "rv", "=", "KeyInfo", "(", "verkey", ",", "metadata", "or", "{", "}", ")", "LOGGER", ".", "debug", "(", "'Wallet.create_signing_key <<< %s'", ",", "rv", ")", "return", "rv" ]

[ "def", "only_once", "(", "action", "=", "None", ")", ":", "if", "action", "is", "None", ":", "# allow to be used as @only_once or @only_once()", "return", "only_once", "action_id", "=", "_action_id", "(", "action", ")", "handler", "=", "Handler", ".", "get", "(", "action", ")", "handler", ".", "add_predicate", "(", "lambda", ":", "not", "was_invoked", "(", "action_id", ")", ")", "handler", ".", "add_post_callback", "(", "partial", "(", "mark_invoked", ",", "action_id", ")", ")", "return", "action" ]

[ "def", "selectInvert", "(", "self", ")", ":", "currLayer", "=", "self", ".", "_currentLayer", "for", "item", "in", "self", ".", "items", "(", ")", ":", "layer", "=", "item", ".", "layer", "(", ")", "if", "(", "layer", "==", "currLayer", "or", "not", "layer", ")", ":", "item", ".", "setSelected", "(", "not", "item", ".", "isSelected", "(", ")", ")" ]

[ "def", "temp45", "(", "msg", ")", ":", "d", "=", "hex2bin", "(", "data", "(", "msg", ")", ")", "sign", "=", "int", "(", "d", "[", "16", "]", ")", "value", "=", "bin2int", "(", "d", "[", "17", ":", "26", "]", ")", "if", "sign", ":", "value", "=", "value", "-", "512", "temp", "=", "value", "*", "0.25", "# celsius", "temp", "=", "round", "(", "temp", ",", "1", ")", "return", "temp" ]

[ "def", "from_ssl_socket", "(", "cls", ",", "ssl_socket", ")", ":", "try", ":", "data", "=", "ssl_socket", ".", "getpeercert", "(", "True", ")", "except", "AttributeError", ":", "# PyPy doesn't have .getpeercert", "data", "=", "None", "if", "not", "data", ":", "logger", ".", "debug", "(", "\"No certificate infromation\"", ")", "return", "cls", "(", ")", "result", "=", "cls", ".", "from_der_data", "(", "data", ")", "result", ".", "validated", "=", "bool", "(", "ssl_socket", ".", "getpeercert", "(", ")", ")", "return", "result" ]

[ "def", "delete_password", "(", "self", ",", "service", ",", "username", ")", ":", "service", "=", "escape_for_ini", "(", "service", ")", "username", "=", "escape_for_ini", "(", "username", ")", "config", "=", "configparser", ".", "RawConfigParser", "(", ")", "if", "os", ".", "path", ".", "exists", "(", "self", ".", "file_path", ")", ":", "config", ".", "read", "(", "self", ".", "file_path", ")", "try", ":", "if", "not", "config", ".", "remove_option", "(", "service", ",", "username", ")", ":", "raise", "PasswordDeleteError", "(", "\"Password not found\"", ")", "except", "configparser", ".", "NoSectionError", ":", "raise", "PasswordDeleteError", "(", "\"Password not found\"", ")", "# update the file", "with", "open", "(", "self", ".", "file_path", ",", "'w'", ")", "as", "config_file", ":", "config", ".", "write", "(", "config_file", ")" ]

[ "def", "two_qubit_state_tomography", "(", "sampler", ":", "sim", ".", "Sampler", ",", "first_qubit", ":", "devices", ".", "GridQubit", ",", "second_qubit", ":", "devices", ".", "GridQubit", ",", "circuit", ":", "circuits", ".", "Circuit", ",", "repetitions", ":", "int", "=", "1000", ")", "->", "TomographyResult", ":", "# The size of the system of linear equations to be solved.", "num_rows", "=", "27", "num_cols", "=", "15", "def", "_measurement", "(", "two_qubit_circuit", ":", "circuits", ".", "Circuit", ")", "->", "np", ".", "ndarray", ":", "two_qubit_circuit", ".", "append", "(", "ops", ".", "measure", "(", "first_qubit", ",", "second_qubit", ",", "key", "=", "'z'", ")", ")", "results", "=", "sampler", ".", "run", "(", "two_qubit_circuit", ",", "repetitions", "=", "repetitions", ")", "results_hist", "=", "results", ".", "histogram", "(", "key", "=", "'z'", ")", "prob_list", "=", "[", "results_hist", "[", "0", "]", ",", "results_hist", "[", "1", "]", ",", "results_hist", "[", "2", "]", "]", "return", "np", ".", "asarray", "(", "prob_list", ")", "/", "repetitions", "sigma_0", "=", "np", ".", "eye", "(", "2", ")", "/", "2.0", "sigma_1", "=", "np", ".", "array", "(", "[", "[", "0.0", ",", "1.0", "]", ",", "[", "1.0", ",", "0.0", "]", "]", ")", "/", "2.0", "sigma_2", "=", "np", ".", "array", "(", "[", "[", "0.0", ",", "-", "1.0j", "]", ",", "[", "1.0j", ",", "0.0", "]", "]", ")", "/", "2.0", "sigma_3", "=", "np", ".", "array", "(", "[", "[", "1.0", ",", "0.0", "]", ",", "[", "0.0", ",", "-", "1.0", "]", "]", ")", "/", "2.0", "sigmas", "=", "[", "sigma_0", ",", "sigma_1", ",", "sigma_2", ",", "sigma_3", "]", "# Stores all 27 measured probabilities (P_00, P_01, P_10 after 9", "# different basis rotations).", "probs", "=", "np", ".", "array", "(", "[", "]", ")", "rots", "=", "[", "ops", ".", "X", "**", "0", ",", "ops", ".", "X", "**", "0.5", ",", "ops", ".", "Y", "**", "0.5", "]", "# Represents the coefficients in front of the c_ij's (-1, 0 or 1) in the", "# system of 27 linear equations.", "mat", "=", "np", ".", "zeros", "(", "(", "num_rows", ",", "num_cols", ")", ")", "# Represents the relative signs between the linear equations for P_00,", "# P_01, and P_10.", "s", "=", "np", ".", "array", "(", "[", "[", "1.0", ",", "1.0", ",", "1.0", "]", ",", "[", "-", "1.0", ",", "1.0", ",", "-", "1.0", "]", ",", "[", "1.0", ",", "-", "1.0", ",", "-", "1.0", "]", "]", ")", "for", "i", ",", "rot_1", "in", "enumerate", "(", "rots", ")", ":", "for", "j", ",", "rot_2", "in", "enumerate", "(", "rots", ")", ":", "m_idx", ",", "indices", ",", "signs", "=", "_indices_after_basis_rot", "(", "i", ",", "j", ")", "mat", "[", "m_idx", ":", "(", "m_idx", "+", "3", ")", ",", "indices", "]", "=", "s", "*", "np", ".", "tile", "(", "signs", ",", "(", "3", ",", "1", ")", ")", "test_circuit", "=", "circuit", "+", "circuits", ".", "Circuit", ".", "from_ops", "(", "rot_1", "(", "second_qubit", ")", ")", "test_circuit", ".", "append", "(", "rot_2", "(", "first_qubit", ")", ")", "probs", "=", "np", ".", "concatenate", "(", "(", "probs", ",", "_measurement", "(", "test_circuit", ")", ")", ")", "c", ",", "_", ",", "_", ",", "_", "=", "np", ".", "linalg", ".", "lstsq", "(", "mat", ",", "4.0", "*", "probs", "-", "1.0", ",", "rcond", "=", "-", "1", ")", "c", "=", "np", ".", "concatenate", "(", "(", "[", "1.0", "]", ",", "c", ")", ")", "c", "=", "c", ".", "reshape", "(", "4", ",", "4", ")", "rho", "=", "np", ".", "zeros", "(", "(", "4", ",", "4", ")", ")", "for", "i", "in", "range", "(", "4", ")", ":", "for", "j", "in", "range", "(", "4", ")", ":", "rho", "=", "rho", "+", "c", "[", "i", ",", "j", "]", "*", "np", ".", "kron", "(", "sigmas", "[", "i", "]", ",", "sigmas", "[", "j", "]", ")", "return", "TomographyResult", "(", "rho", ")" ]

[ "def", "set_position", "(", "self", ",", "position", ")", ":", "if", "position", "<", "0", ":", "position", "+=", "len", "(", "self", ".", "checkdefs", ")", "while", "position", ">=", "len", "(", "self", ".", "checkdefs", ")", ":", "self", ".", "checkdefs", ".", "append", "(", "(", "[", "]", ",", "[", "]", ")", ")", "self", ".", "position", "=", "position" ]

[ "def", "median", "(", "timeseries", ",", "segmentlength", ",", "noverlap", "=", "None", ",", "window", "=", "None", ",", "plan", "=", "None", ")", ":", "return", "_lal_spectrum", "(", "timeseries", ",", "segmentlength", ",", "noverlap", "=", "noverlap", ",", "method", "=", "'median'", ",", "window", "=", "window", ",", "plan", "=", "plan", ")" ]

[ "def", "get_soap_locals", "(", "obj", ",", "Hpos", ",", "alp", ",", "bet", ",", "rCut", "=", "5.0", ",", "nMax", "=", "5", ",", "Lmax", "=", "5", ",", "crossOver", "=", "True", ",", "all_atomtypes", "=", "None", ",", "eta", "=", "1.0", ")", ":", "rCutHard", "=", "rCut", "+", "5", "assert", "Lmax", "<=", "9", ",", "\"l cannot exceed 9. Lmax={}\"", ".", "format", "(", "Lmax", ")", "assert", "Lmax", ">=", "0", ",", "\"l cannot be negative.Lmax={}\"", ".", "format", "(", "Lmax", ")", "assert", "rCutHard", "<", "17.0001", ",", "\"hard radius cuttof cannot be larger than 17 Angs. rCut={}\"", ".", "format", "(", "rCutHard", ")", "assert", "rCutHard", ">", "1.999", ",", "\"hard redius cuttof cannot be lower than 1 Ang. rCut={}\"", ".", "format", "(", "rCutHard", ")", "assert", "nMax", ">=", "2", ",", "\"number of basis functions cannot be lower than 2. nMax={}\"", ".", "format", "(", "nMax", ")", "assert", "nMax", "<=", "13", ",", "\"number of basis functions cannot exceed 12. nMax={}\"", ".", "format", "(", "nMax", ")", "assert", "eta", ">=", "0.0001", ",", "\"Eta cannot be zero or negative. nMax={}\"", ".", "format", "(", "eta", ")", "# get clusgeo internal format for c-code", "Apos", ",", "typeNs", ",", "py_Ntypes", ",", "atomtype_lst", ",", "totalAN", "=", "_format_ase2clusgeo", "(", "obj", ",", "all_atomtypes", ")", "Hpos", "=", "np", ".", "array", "(", "Hpos", ")", "py_Hsize", "=", "Hpos", ".", "shape", "[", "0", "]", "# flatten arrays", "Hpos", "=", "Hpos", ".", "flatten", "(", ")", "alp", "=", "alp", ".", "flatten", "(", ")", "bet", "=", "bet", ".", "flatten", "(", ")", "# convert int to c_int", "lMax", "=", "c_int", "(", "Lmax", ")", "Hsize", "=", "c_int", "(", "py_Hsize", ")", "Ntypes", "=", "c_int", "(", "py_Ntypes", ")", "totalAN", "=", "c_int", "(", "totalAN", ")", "rCutHard", "=", "c_double", "(", "rCutHard", ")", "Nsize", "=", "c_int", "(", "nMax", ")", "c_eta", "=", "c_double", "(", "eta", ")", "#convert int array to c_int array", "typeNs", "=", "(", "c_int", "*", "len", "(", "typeNs", ")", ")", "(", "*", "typeNs", ")", "# convert to c_double arrays", "# alphas", "alphas", "=", "(", "c_double", "*", "len", "(", "alp", ")", ")", "(", "*", "alp", ".", "tolist", "(", ")", ")", "# betas", "betas", "=", "(", "c_double", "*", "len", "(", "bet", ")", ")", "(", "*", "bet", ".", "tolist", "(", ")", ")", "#Apos", "axyz", "=", "(", "c_double", "*", "len", "(", "Apos", ")", ")", "(", "*", "Apos", ".", "tolist", "(", ")", ")", "#Hpos", "hxyz", "=", "(", "c_double", "*", "len", "(", "Hpos", ")", ")", "(", "*", "Hpos", ".", "tolist", "(", ")", ")", "### START SOAP###", "#path_to_so = os.path.dirname(os.path.abspath(__file__))", "_PATH_TO_SOAPLITE_SO", "=", "os", ".", "path", ".", "dirname", "(", "os", ".", "path", ".", "abspath", "(", "__file__", ")", ")", "_SOAPLITE_SOFILES", "=", "glob", ".", "glob", "(", "\"\"", ".", "join", "(", "[", "_PATH_TO_SOAPLITE_SO", ",", "\"/../lib/libsoap*.*so\"", "]", ")", ")", "## NOT SURE ABOUT THIS", "if", "py_Ntypes", "==", "1", "or", "(", "not", "crossOver", ")", ":", "substring", "=", "\"lib/libsoapPySig.\"", "libsoap", "=", "CDLL", "(", "next", "(", "(", "s", "for", "s", "in", "_SOAPLITE_SOFILES", "if", "substring", "in", "s", ")", ",", "None", ")", ")", "libsoap", ".", "soap", ".", "argtypes", "=", "[", "POINTER", "(", "c_double", ")", ",", "POINTER", "(", "c_double", ")", ",", "POINTER", "(", "c_double", ")", ",", "POINTER", "(", "c_double", ")", ",", "POINTER", "(", "c_double", ")", ",", "POINTER", "(", "c_int", ")", ",", "c_double", ",", "c_int", ",", "c_int", ",", "c_int", ",", "c_int", ",", "c_int", ",", "c_double", "]", "libsoap", ".", "soap", ".", "restype", "=", "POINTER", "(", "c_double", ")", "c", "=", "(", "c_double", "*", "(", "int", "(", "(", "nMax", "*", "(", "nMax", "+", "1", ")", ")", "/", "2", ")", "*", "(", "Lmax", "+", "1", ")", "*", "py_Ntypes", "*", "py_Hsize", ")", ")", "(", ")", "libsoap", ".", "soap", "(", "c", ",", "axyz", ",", "hxyz", ",", "alphas", ",", "betas", ",", "typeNs", ",", "rCutHard", ",", "totalAN", ",", "Ntypes", ",", "Nsize", ",", "lMax", ",", "Hsize", ",", "c_eta", ")", "else", ":", "substring", "=", "\"lib/libsoapGTO.\"", "libsoapGTO", "=", "CDLL", "(", "next", "(", "(", "s", "for", "s", "in", "_SOAPLITE_SOFILES", "if", "substring", "in", "s", ")", ",", "None", ")", ")", "libsoapGTO", ".", "soap", ".", "argtypes", "=", "[", "POINTER", "(", "c_double", ")", ",", "POINTER", "(", "c_double", ")", ",", "POINTER", "(", "c_double", ")", ",", "POINTER", "(", "c_double", ")", ",", "POINTER", "(", "c_double", ")", ",", "POINTER", "(", "c_int", ")", ",", "c_double", ",", "c_int", ",", "c_int", ",", "c_int", ",", "c_int", ",", "c_int", ",", "c_double", "]", "libsoapGTO", ".", "soap", ".", "restype", "=", "POINTER", "(", "c_double", ")", "c", "=", "(", "c_double", "*", "(", "int", "(", "(", "nMax", "*", "(", "nMax", "+", "1", ")", ")", "/", "2", ")", "*", "(", "Lmax", "+", "1", ")", "*", "int", "(", "(", "py_Ntypes", "*", "(", "py_Ntypes", "+", "1", ")", ")", "/", "2", ")", "*", "py_Hsize", ")", ")", "(", ")", "libsoapGTO", ".", "soap", "(", "c", ",", "axyz", ",", "hxyz", ",", "alphas", ",", "betas", ",", "typeNs", ",", "rCutHard", ",", "totalAN", ",", "Ntypes", ",", "Nsize", ",", "lMax", ",", "Hsize", ",", "c_eta", ")", "# return c;", "if", "crossOver", ":", "crosTypes", "=", "int", "(", "(", "py_Ntypes", "*", "(", "py_Ntypes", "+", "1", ")", ")", "/", "2", ")", "shape", "=", "(", "py_Hsize", ",", "int", "(", "(", "nMax", "*", "(", "nMax", "+", "1", ")", ")", "/", "2", ")", "*", "(", "Lmax", "+", "1", ")", "*", "crosTypes", ")", "else", ":", "shape", "=", "(", "py_Hsize", ",", "int", "(", "(", "nMax", "*", "(", "nMax", "+", "1", ")", ")", "/", "2", ")", "*", "(", "Lmax", "+", "1", ")", "*", "py_Ntypes", ")", "a", "=", "np", ".", "ctypeslib", ".", "as_array", "(", "c", ")", "a", "=", "a", ".", "reshape", "(", "shape", ")", "return", "a" ]

[ "def", "computeGeneralExpectations", "(", "self", ",", "A_in", ",", "u_ln", ",", "state_list", ",", "compute_uncertainty", "=", "True", ",", "uncertainty_method", "=", "None", ",", "warning_cutoff", "=", "1.0e-10", ",", "return_theta", "=", "False", ")", ":", "# Retrieve N and K for convenience.", "S", "=", "len", "(", "state_list", ")", "# number of computed expectations examined", "K", "=", "self", ".", "K", "N", "=", "self", ".", "N", "# N is total number of samples", "# make observables all positive", "A_list", "=", "np", ".", "unique", "(", "state_list", "[", ":", ",", "0", "]", ")", "I", "=", "len", "(", "A_list", ")", "# number of observables used", "A_min", "=", "np", ".", "zeros", "(", "[", "I", "]", ",", "dtype", "=", "np", ".", "float64", ")", "for", "i", "in", "A_list", ":", "# only need to zero the ones we will use. May be some repetition here.", "A_min", "[", "i", "]", "=", "np", ".", "min", "(", "A_in", "[", "i", ",", ":", "]", ")", "#find the minimum", "A_in", "[", "i", ",", ":", "]", "=", "A_in", "[", "i", ",", ":", "]", "-", "(", "A_min", "[", "i", "]", "-", "1", ")", "#all values now positive so that we can work in logarithmic scale", "# Augment W_nk, N_k, and c_k for q_A(x) for the observables, with one", "# row for the specified state and I rows for the observable at that", "# state.", "# log weight matrix", "sizea", "=", "K", "+", "2", "*", "S", "# augmented size", "Log_W_nk", "=", "np", ".", "zeros", "(", "[", "N", ",", "sizea", "]", ",", "np", ".", "float64", ")", "# log weight matrix", "N_k", "=", "np", ".", "zeros", "(", "[", "sizea", "]", ",", "np", ".", "int32", ")", "# counts", "f_k", "=", "np", ".", "zeros", "(", "[", "sizea", "]", ",", "np", ".", "float64", ")", "# free energies", "# Fill in first section of matrix with existing q_k(x) from states.", "Log_W_nk", "[", ":", ",", "0", ":", "K", "]", "=", "self", ".", "Log_W_nk", "N_k", "[", "0", ":", "K", "]", "=", "self", ".", "N_k", "f_k", "[", "0", ":", "K", "]", "=", "self", ".", "f_k", "# Compute row of W matrix for the extra states corresponding to u_ln according to the state list", "for", "s", "in", "range", "(", "S", ")", ":", "l", "=", "state_list", "[", "s", ",", "1", "]", "la", "=", "K", "+", "s", "#l augmented", "Log_W_nk", "[", ":", ",", "la", "]", "=", "self", ".", "_computeUnnormalizedLogWeights", "(", "u_ln", "[", "l", ",", ":", "]", ")", "f_k", "[", "la", "]", "=", "-", "_logsum", "(", "Log_W_nk", "[", ":", ",", "la", "]", ")", "Log_W_nk", "[", ":", ",", "la", "]", "+=", "f_k", "[", "l", "]", "# Compute the remaining rows/columns of W_nk and c_k for the", "# observables.", "for", "s", "in", "range", "(", "S", ")", ":", "sa", "=", "K", "+", "S", "+", "s", "# augmented s", "i", "=", "state_list", "[", "s", ",", "0", "]", "l", "=", "state_list", "[", "s", ",", "1", "]", "Log_W_nk", "[", ":", ",", "sa", "]", "=", "np", ".", "log", "(", "A_in", "[", "i", ",", ":", "]", ")", "+", "Log_W_nk", "[", ":", ",", "K", "+", "l", "]", "f_k", "[", "sa", "]", "=", "-", "_logsum", "(", "Log_W_nk", "[", ":", ",", "sa", "]", ")", "Log_W_nk", "[", ":", ",", "sa", "]", "+=", "f_k", "[", "sa", "]", "# normalize this row", "# Compute estimates.", "A_i", "=", "np", ".", "zeros", "(", "[", "S", "]", ",", "np", ".", "float64", ")", "for", "s", "in", "range", "(", "S", ")", ":", "A_i", "[", "s", "]", "=", "np", ".", "exp", "(", "-", "f_k", "[", "K", "+", "S", "+", "s", "]", ")", "if", "compute_uncertainty", "or", "return_theta", ":", "# Compute augmented asymptotic covariance matrix.", "W_nk", "=", "np", ".", "exp", "(", "Log_W_nk", ")", "Theta_ij", "=", "self", ".", "_computeAsymptoticCovarianceMatrix", "(", "W_nk", ",", "N_k", ",", "method", "=", "uncertainty_method", ")", "if", "compute_uncertainty", ":", "# Compute estimates of statistical covariance", "# these variances will be the same whether or not we subtract a different constant from each A_i", "# todo: vectorize", "# compute the covariance component without doing the double loop", "d2A_ij", "=", "np", ".", "zeros", "(", "[", "S", ",", "S", "]", ",", "np", ".", "float64", ")", "for", "i", "in", "range", "(", "S", ")", ":", "si", "=", "K", "+", "S", "+", "i", "li", "=", "K", "+", "state_list", "[", "i", ",", "1", "]", "for", "j", "in", "range", "(", "S", ")", ":", "sj", "=", "K", "+", "S", "+", "j", "lj", "=", "K", "+", "state_list", "[", "j", ",", "1", "]", "d2A_ij", "[", "i", ",", "j", "]", "=", "A_i", "[", "i", "]", "*", "A_i", "[", "j", "]", "*", "(", "Theta_ij", "[", "si", ",", "sj", "]", "-", "Theta_ij", "[", "si", ",", "li", "]", "-", "Theta_ij", "[", "lj", ",", "sj", "]", "+", "Theta_ij", "[", "li", ",", "lj", "]", ")", "# Now that covariances are computed, add the constants back to A_i that", "# were required to enforce positivity", "for", "s", "in", "range", "(", "S", ")", ":", "A_i", "[", "s", "]", "+=", "(", "A_min", "[", "state_list", "[", "s", ",", "0", "]", "]", "-", "1", ")", "# these values may be used outside the routine, so copy back.", "for", "i", "in", "A_list", ":", "A_in", "[", "i", ",", ":", "]", "=", "A_in", "[", "i", ",", ":", "]", "+", "(", "A_min", "[", "i", "]", "-", "1", ")", "returns", "=", "[", "]", "returns", ".", "append", "(", "A_i", ")", "if", "compute_uncertainty", ":", "returns", ".", "append", "(", "d2A_ij", ")", "if", "return_theta", ":", "returns", ".", "append", "(", "Theta_ij", ")", "# Return expectations and uncertainties.", "return", "returns" ]

[ "def", "by_publications", "(", "self", ")", ":", "if", "not", "spectator_apps", ".", "is_enabled", "(", "'reading'", ")", ":", "raise", "ImproperlyConfigured", "(", "\"To use the CreatorManager.by_publications() method, 'spectator.reading' must by in INSTALLED_APPS.\"", ")", "qs", "=", "self", ".", "get_queryset", "(", ")", "qs", "=", "qs", ".", "exclude", "(", "publications__reading__isnull", "=", "True", ")", ".", "annotate", "(", "num_publications", "=", "Count", "(", "'publications'", ")", ")", ".", "order_by", "(", "'-num_publications'", ",", "'name_sort'", ")", "return", "qs" ]

[ "def", "processPrePrepare", "(", "self", ",", "pre_prepare", ":", "PrePrepare", ",", "sender", ":", "str", ")", ":", "key", "=", "(", "pre_prepare", ".", "viewNo", ",", "pre_prepare", ".", "ppSeqNo", ")", "self", ".", "logger", ".", "debug", "(", "\"{} received PRE-PREPARE{} from {}\"", ".", "format", "(", "self", ",", "key", ",", "sender", ")", ")", "# TODO: should we still do it?", "# Converting each req_idrs from list to tuple", "req_idrs", "=", "{", "f", ".", "REQ_IDR", ".", "nm", ":", "[", "key", "for", "key", "in", "pre_prepare", ".", "reqIdr", "]", "}", "pre_prepare", "=", "updateNamedTuple", "(", "pre_prepare", ",", "*", "*", "req_idrs", ")", "def", "report_suspicious", "(", "reason", ")", ":", "ex", "=", "SuspiciousNode", "(", "sender", ",", "reason", ",", "pre_prepare", ")", "self", ".", "report_suspicious_node", "(", "ex", ")", "why_not", "=", "self", ".", "_can_process_pre_prepare", "(", "pre_prepare", ",", "sender", ")", "if", "why_not", "is", "None", ":", "why_not_applied", "=", "self", ".", "_process_valid_preprepare", "(", "pre_prepare", ",", "sender", ")", "if", "why_not_applied", "is", "not", "None", ":", "if", "why_not_applied", "==", "PP_APPLY_REJECT_WRONG", ":", "report_suspicious", "(", "Suspicions", ".", "PPR_REJECT_WRONG", ")", "elif", "why_not_applied", "==", "PP_APPLY_WRONG_DIGEST", ":", "report_suspicious", "(", "Suspicions", ".", "PPR_DIGEST_WRONG", ")", "elif", "why_not_applied", "==", "PP_APPLY_WRONG_STATE", ":", "report_suspicious", "(", "Suspicions", ".", "PPR_STATE_WRONG", ")", "elif", "why_not_applied", "==", "PP_APPLY_ROOT_HASH_MISMATCH", ":", "report_suspicious", "(", "Suspicions", ".", "PPR_TXN_WRONG", ")", "elif", "why_not_applied", "==", "PP_APPLY_HOOK_ERROR", ":", "report_suspicious", "(", "Suspicions", ".", "PPR_PLUGIN_EXCEPTION", ")", "elif", "why_not_applied", "==", "PP_SUB_SEQ_NO_WRONG", ":", "report_suspicious", "(", "Suspicions", ".", "PPR_SUB_SEQ_NO_WRONG", ")", "elif", "why_not_applied", "==", "PP_NOT_FINAL", ":", "# this is fine, just wait for another", "return", "elif", "why_not_applied", "==", "PP_APPLY_AUDIT_HASH_MISMATCH", ":", "report_suspicious", "(", "Suspicions", ".", "PPR_AUDIT_TXN_ROOT_HASH_WRONG", ")", "elif", "why_not_applied", "==", "PP_REQUEST_ALREADY_ORDERED", ":", "report_suspicious", "(", "Suspicions", ".", "PPR_WITH_ORDERED_REQUEST", ")", "elif", "why_not", "==", "PP_CHECK_NOT_FROM_PRIMARY", ":", "report_suspicious", "(", "Suspicions", ".", "PPR_FRM_NON_PRIMARY", ")", "elif", "why_not", "==", "PP_CHECK_TO_PRIMARY", ":", "report_suspicious", "(", "Suspicions", ".", "PPR_TO_PRIMARY", ")", "elif", "why_not", "==", "PP_CHECK_DUPLICATE", ":", "report_suspicious", "(", "Suspicions", ".", "DUPLICATE_PPR_SENT", ")", "elif", "why_not", "==", "PP_CHECK_INCORRECT_POOL_STATE_ROOT", ":", "report_suspicious", "(", "Suspicions", ".", "PPR_POOL_STATE_ROOT_HASH_WRONG", ")", "elif", "why_not", "==", "PP_CHECK_OLD", ":", "self", ".", "logger", ".", "info", "(", "\"PRE-PREPARE {} has ppSeqNo lower \"", "\"then the latest one - ignoring it\"", ".", "format", "(", "key", ")", ")", "elif", "why_not", "==", "PP_CHECK_REQUEST_NOT_FINALIZED", ":", "absents", "=", "set", "(", ")", "non_fin", "=", "set", "(", ")", "non_fin_payload", "=", "set", "(", ")", "for", "key", "in", "pre_prepare", ".", "reqIdr", ":", "req", "=", "self", ".", "requests", ".", "get", "(", "key", ")", "if", "req", "is", "None", ":", "absents", ".", "add", "(", "key", ")", "elif", "not", "req", ".", "finalised", ":", "non_fin", ".", "add", "(", "key", ")", "non_fin_payload", ".", "add", "(", "req", ".", "request", ".", "payload_digest", ")", "absent_str", "=", "', '", ".", "join", "(", "str", "(", "key", ")", "for", "key", "in", "absents", ")", "non_fin_str", "=", "', '", ".", "join", "(", "'{} ({} : {})'", ".", "format", "(", "str", "(", "key", ")", ",", "str", "(", "len", "(", "self", ".", "requests", "[", "key", "]", ".", "propagates", ")", ")", ",", "', '", ".", "join", "(", "self", ".", "requests", "[", "key", "]", ".", "propagates", ".", "keys", "(", ")", ")", ")", "for", "key", "in", "non_fin", ")", "self", ".", "logger", ".", "warning", "(", "\"{} found requests in the incoming pp, of {} ledger, that are not finalized. \"", "\"{} of them don't have propagates: {}.\"", "\"{} of them don't have enough propagates: {}.\"", ".", "format", "(", "self", ",", "pre_prepare", ".", "ledgerId", ",", "len", "(", "absents", ")", ",", "absent_str", ",", "len", "(", "non_fin", ")", ",", "non_fin_str", ")", ")", "def", "signal_suspicious", "(", "req", ")", ":", "self", ".", "logger", ".", "info", "(", "\"Request digest {} already ordered. Discard {} \"", "\"from {}\"", ".", "format", "(", "req", ",", "pre_prepare", ",", "sender", ")", ")", "report_suspicious", "(", "Suspicions", ".", "PPR_WITH_ORDERED_REQUEST", ")", "# checking for payload digest is more effective", "for", "payload_key", "in", "non_fin_payload", ":", "if", "self", ".", "node", ".", "seqNoDB", ".", "get_by_payload_digest", "(", "payload_key", ")", "!=", "(", "None", ",", "None", ")", ":", "signal_suspicious", "(", "payload_key", ")", "return", "# for absents we can only check full digest", "for", "full_key", "in", "absents", ":", "if", "self", ".", "node", ".", "seqNoDB", ".", "get_by_full_digest", "(", "full_key", ")", "is", "not", "None", ":", "signal_suspicious", "(", "full_key", ")", "return", "bad_reqs", "=", "absents", "|", "non_fin", "self", ".", "enqueue_pre_prepare", "(", "pre_prepare", ",", "sender", ",", "bad_reqs", ")", "# TODO: An optimisation might be to not request PROPAGATEs", "# if some PROPAGATEs are present or a client request is", "# present and sufficient PREPAREs and PRE-PREPARE are present,", "# then the digest can be compared but this is expensive as the", "# PREPARE and PRE-PREPARE contain a combined digest", "self", ".", "_schedule", "(", "partial", "(", "self", ".", "request_propagates_if_needed", ",", "bad_reqs", ",", "pre_prepare", ")", ",", "self", ".", "config", ".", "PROPAGATE_REQUEST_DELAY", ")", "elif", "why_not", "==", "PP_CHECK_NOT_NEXT", ":", "pp_view_no", "=", "pre_prepare", ".", "viewNo", "pp_seq_no", "=", "pre_prepare", ".", "ppSeqNo", "last_pp_view_no", ",", "last_pp_seq_no", "=", "self", ".", "__last_pp_3pc", "if", "pp_view_no", ">=", "last_pp_view_no", "and", "(", "self", ".", "isMaster", "or", "self", ".", "last_ordered_3pc", "[", "1", "]", "!=", "0", ")", ":", "seq_frm", "=", "last_pp_seq_no", "+", "1", "if", "pp_view_no", "==", "last_pp_view_no", "else", "1", "seq_to", "=", "pp_seq_no", "-", "1", "if", "seq_to", ">=", "seq_frm", ">=", "pp_seq_no", "-", "CHK_FREQ", "+", "1", ":", "self", ".", "logger", ".", "warning", "(", "\"{} missing PRE-PREPAREs from {} to {}, \"", "\"going to request\"", ".", "format", "(", "self", ",", "seq_frm", ",", "seq_to", ")", ")", "self", ".", "_request_missing_three_phase_messages", "(", "pp_view_no", ",", "seq_frm", ",", "seq_to", ")", "self", ".", "enqueue_pre_prepare", "(", "pre_prepare", ",", "sender", ")", "self", ".", "_setup_last_ordered_for_non_master", "(", ")", "elif", "why_not", "==", "PP_CHECK_WRONG_TIME", ":", "key", "=", "(", "pre_prepare", ".", "viewNo", ",", "pre_prepare", ".", "ppSeqNo", ")", "item", "=", "(", "pre_prepare", ",", "sender", ",", "False", ")", "self", ".", "pre_prepares_stashed_for_incorrect_time", "[", "key", "]", "=", "item", "report_suspicious", "(", "Suspicions", ".", "PPR_TIME_WRONG", ")", "elif", "why_not", "==", "BlsBftReplica", ".", "PPR_BLS_MULTISIG_WRONG", ":", "report_suspicious", "(", "Suspicions", ".", "PPR_BLS_MULTISIG_WRONG", ")", "else", ":", "self", ".", "logger", ".", "warning", "(", "\"Unknown PRE-PREPARE check status: {}\"", ".", "format", "(", "why_not", ")", ")" ]

[ "def", "impute_dataframe_range", "(", "df_impute", ",", "col_to_max", ",", "col_to_min", ",", "col_to_median", ")", ":", "columns", "=", "df_impute", ".", "columns", "# Making sure col_to_median, col_to_max and col_to_min have entries for every column", "if", "not", "set", "(", "columns", ")", "<=", "set", "(", "col_to_median", ".", "keys", "(", ")", ")", "or", "not", "set", "(", "columns", ")", "<=", "set", "(", "col_to_max", ".", "keys", "(", ")", ")", "or", "not", "set", "(", "columns", ")", "<=", "set", "(", "col_to_min", ".", "keys", "(", ")", ")", ":", "raise", "ValueError", "(", "\"Some of the dictionaries col_to_median, col_to_max, col_to_min contains more or less keys \"", "\"than the column names in df\"", ")", "# check if there are non finite values for the replacement", "if", "np", ".", "any", "(", "~", "np", ".", "isfinite", "(", "list", "(", "col_to_median", ".", "values", "(", ")", ")", ")", ")", "or", "np", ".", "any", "(", "~", "np", ".", "isfinite", "(", "list", "(", "col_to_min", ".", "values", "(", ")", ")", ")", ")", "or", "np", ".", "any", "(", "~", "np", ".", "isfinite", "(", "list", "(", "col_to_max", ".", "values", "(", ")", ")", ")", ")", ":", "raise", "ValueError", "(", "\"Some of the dictionaries col_to_median, col_to_max, col_to_min contains non finite values \"", "\"to replace\"", ")", "# Make the replacement dataframes as large as the real one", "col_to_max", "=", "pd", ".", "DataFrame", "(", "[", "col_to_max", "]", "*", "len", "(", "df_impute", ")", ",", "index", "=", "df_impute", ".", "index", ")", "col_to_min", "=", "pd", ".", "DataFrame", "(", "[", "col_to_min", "]", "*", "len", "(", "df_impute", ")", ",", "index", "=", "df_impute", ".", "index", ")", "col_to_median", "=", "pd", ".", "DataFrame", "(", "[", "col_to_median", "]", "*", "len", "(", "df_impute", ")", ",", "index", "=", "df_impute", ".", "index", ")", "df_impute", ".", "where", "(", "df_impute", ".", "values", "!=", "np", ".", "PINF", ",", "other", "=", "col_to_max", ",", "inplace", "=", "True", ")", "df_impute", ".", "where", "(", "df_impute", ".", "values", "!=", "np", ".", "NINF", ",", "other", "=", "col_to_min", ",", "inplace", "=", "True", ")", "df_impute", ".", "where", "(", "~", "np", ".", "isnan", "(", "df_impute", ".", "values", ")", ",", "other", "=", "col_to_median", ",", "inplace", "=", "True", ")", "df_impute", ".", "astype", "(", "np", ".", "float64", ",", "copy", "=", "False", ")", "return", "df_impute" ]

[ "def", "vprjpi", "(", "vin", ",", "projpl", ",", "invpl", ")", ":", "vin", "=", "stypes", ".", "toDoubleVector", "(", "vin", ")", "vout", "=", "stypes", ".", "emptyDoubleVector", "(", "3", ")", "found", "=", "ctypes", ".", "c_int", "(", ")", "libspice", ".", "vprjpi_c", "(", "vin", ",", "ctypes", ".", "byref", "(", "projpl", ")", ",", "ctypes", ".", "byref", "(", "invpl", ")", ",", "vout", ",", "ctypes", ".", "byref", "(", "found", ")", ")", "return", "stypes", ".", "cVectorToPython", "(", "vout", ")", ",", "bool", "(", "found", ".", "value", ")" ]

[ "def", "find_duplicate_metabolites_in_compartments", "(", "model", ")", ":", "unique_identifiers", "=", "[", "\"inchikey\"", ",", "\"inchi\"", "]", "duplicates", "=", "[", "]", "for", "met_1", ",", "met_2", "in", "combinations", "(", "model", ".", "metabolites", ",", "2", ")", ":", "if", "met_1", ".", "compartment", "==", "met_2", ".", "compartment", ":", "for", "key", "in", "unique_identifiers", ":", "if", "key", "in", "met_1", ".", "annotation", "and", "key", "in", "met_2", ".", "annotation", ":", "if", "met_1", ".", "annotation", "[", "key", "]", "==", "met_2", ".", "annotation", "[", "key", "]", ":", "duplicates", ".", "append", "(", "(", "met_1", ".", "id", ",", "met_2", ".", "id", ")", ")", "break", "return", "duplicates" ]

[ "def", "peak_memory_mb", "(", ")", "->", "float", ":", "if", "resource", "is", "None", "or", "sys", ".", "platform", "not", "in", "(", "'linux'", ",", "'darwin'", ")", ":", "return", "0.0", "# TODO(joelgrus): For whatever, our pinned version 0.521 of mypy does not like", "# next line, but later versions (e.g. 0.530) are fine with it. Once we get that", "# figured out, remove the type: ignore.", "peak", "=", "resource", ".", "getrusage", "(", "resource", ".", "RUSAGE_SELF", ")", ".", "ru_maxrss", "# type: ignore", "if", "sys", ".", "platform", "==", "'darwin'", ":", "# On OSX the result is in bytes.", "return", "peak", "/", "1_000_000", "else", ":", "# On Linux the result is in kilobytes.", "return", "peak", "/", "1_000" ]

[ "def", "createObjectMachine", "(", "machineType", ",", "*", "*", "kwargs", ")", ":", "if", "machineType", "not", "in", "ObjectMachineTypes", ".", "getTypes", "(", ")", ":", "raise", "RuntimeError", "(", "\"Unknown model type: \"", "+", "machineType", ")", "return", "getattr", "(", "ObjectMachineTypes", ",", "machineType", ")", "(", "*", "*", "kwargs", ")" ]

[ "def", "thin_samples_for_writing", "(", "fp", ",", "samples", ",", "parameters", ",", "last_iteration", ")", ":", "if", "fp", ".", "thinned_by", ">", "1", ":", "if", "last_iteration", "is", "None", ":", "raise", "ValueError", "(", "\"File's thinned_by attribute is > 1 ({}), \"", "\"but last_iteration not provided.\"", ".", "format", "(", "fp", ".", "thinned_by", ")", ")", "thinned_samples", "=", "{", "}", "for", "param", "in", "parameters", ":", "data", "=", "samples", "[", "param", "]", "nsamples", "=", "data", ".", "shape", "[", "-", "1", "]", "# To figure out where to start:", "# the last iteration in the file + the file's thinning interval", "# gives the iteration of the next sample that should be written;", "# last_iteration - nsamples gives the iteration of the first", "# sample in samples. Subtracting the latter from the former - 1", "# (-1 to convert from iteration to index) therefore gives the index", "# in the samples data to start using samples.", "thin_start", "=", "fp", ".", "last_iteration", "(", "param", ")", "+", "fp", ".", "thinned_by", "-", "(", "last_iteration", "-", "nsamples", ")", "-", "1", "thinned_samples", "[", "param", "]", "=", "data", "[", "...", ",", "thin_start", ":", ":", "fp", ".", "thinned_by", "]", "else", ":", "thinned_samples", "=", "samples", "return", "thinned_samples" ]

[ "def", "_control_resp", "(", "self", ",", "data", ",", "state", ")", ":", "if", "_is_control_response", "(", "data", ")", ":", "ack_state", "=", "bytes", "(", "[", "data", "[", "22", "]", "]", ")", "if", "state", "==", "ack_state", ":", "_LOGGER", ".", "debug", "(", "\"Received state ack from %s, state: %s\"", ",", "self", ".", "host", ",", "ord", "(", "ack_state", ")", ")", "return", "ack_state" ]

[ "def", "_hash_filter_fn", "(", "self", ",", "filter_fn", ",", "*", "*", "kwargs", ")", ":", "filter_fn_name", "=", "self", ".", "_get_function_name", "(", "filter_fn", ",", "default", "=", "\"filter-none\"", ")", "logger", ".", "debug", "(", "\"Computing hash for filter_fn: {} with kwargs {}\"", ".", "format", "(", "filter_fn_name", ",", "str", "(", "dict", "(", "*", "*", "kwargs", ")", ")", ")", ")", "# hash function source code", "fn_source", "=", "str", "(", "dill", ".", "source", ".", "getsource", "(", "filter_fn", ")", ")", "pickled_fn_source", "=", "pickle", ".", "dumps", "(", "fn_source", ")", "## encode as byte string", "hashed_fn_source", "=", "int", "(", "hashlib", ".", "sha1", "(", "pickled_fn_source", ")", ".", "hexdigest", "(", ")", ",", "16", ")", "%", "(", "10", "**", "11", ")", "# hash kwarg values", "kw_dict", "=", "dict", "(", "*", "*", "kwargs", ")", "kw_hash", "=", "list", "(", ")", "if", "not", "kw_dict", ":", "kw_hash", "=", "[", "\"default\"", "]", "else", ":", "[", "kw_hash", ".", "append", "(", "\"{}-{}\"", ".", "format", "(", "key", ",", "h", ")", ")", "for", "(", "key", ",", "h", ")", "in", "sorted", "(", "kw_dict", ".", "items", "(", ")", ")", "]", "# hash closure vars - for case where filter_fn is defined within closure of filter_fn", "closure", "=", "[", "]", "nonlocals", "=", "inspect", ".", "getclosurevars", "(", "filter_fn", ")", ".", "nonlocals", "for", "(", "key", ",", "val", ")", "in", "nonlocals", ".", "items", "(", ")", ":", "## capture hash for any function within closure", "if", "inspect", ".", "isfunction", "(", "val", ")", ":", "closure", ".", "append", "(", "self", ".", "_hash_filter_fn", "(", "val", ")", ")", "closure", ".", "sort", "(", ")", "# Sorted for file name consistency", "closure_str", "=", "\"null\"", "if", "len", "(", "closure", ")", "==", "0", "else", "\"-\"", ".", "join", "(", "closure", ")", "# construct final string comprising hashed components", "hashed_fn", "=", "\".\"", ".", "join", "(", "[", "\"-\"", ".", "join", "(", "[", "filter_fn_name", ",", "str", "(", "hashed_fn_source", ")", "]", ")", ",", "\".\"", ".", "join", "(", "kw_hash", ")", ",", "closure_str", "]", ")", "return", "hashed_fn" ]

[ "def", "_ExtractGoogleDocsSearchQuery", "(", "self", ",", "url", ")", ":", "if", "'q='", "not", "in", "url", ":", "return", "None", "line", "=", "self", ".", "_GetBetweenQEqualsAndAmpersand", "(", "url", ")", "if", "not", "line", ":", "return", "None", "return", "line", ".", "replace", "(", "'+'", ",", "' '", ")" ]

[ "def", "getOverlayTransformAbsolute", "(", "self", ",", "ulOverlayHandle", ")", ":", "fn", "=", "self", ".", "function_table", ".", "getOverlayTransformAbsolute", "peTrackingOrigin", "=", "ETrackingUniverseOrigin", "(", ")", "pmatTrackingOriginToOverlayTransform", "=", "HmdMatrix34_t", "(", ")", "result", "=", "fn", "(", "ulOverlayHandle", ",", "byref", "(", "peTrackingOrigin", ")", ",", "byref", "(", "pmatTrackingOriginToOverlayTransform", ")", ")", "return", "result", ",", "peTrackingOrigin", ",", "pmatTrackingOriginToOverlayTransform" ]

[ "def", "get_pac", "(", "self", ")", ":", "if", "self", ".", "_tried_get_pac", ":", "return", "self", ".", "_proxy_resolver", ".", "pac", "if", "self", ".", "_proxy_resolver", "else", "None", "if", "not", "self", ".", "pac_enabled", ":", "return", "pac", "=", "get_pac", "(", ")", "self", ".", "_tried_get_pac", "=", "True", "if", "pac", ":", "self", ".", "_proxy_resolver", "=", "self", ".", "_get_proxy_resolver", "(", "pac", ")", "return", "pac" ]

[ "def", "get_inline_views_from_fieldsets", "(", "fieldsets", ")", ":", "inline_views", "=", "[", "]", "for", "_", ",", "opts", "in", "fieldsets", "or", "(", ")", ":", "if", "'fieldsets'", "in", "opts", ":", "inline_views", "+=", "get_inline_views_from_fieldsets", "(", "opts", ".", "get", "(", "'fieldsets'", ")", ")", "elif", "'inline_view'", "in", "opts", ":", "inline_views", ".", "append", "(", "opts", ".", "get", "(", "'inline_view'", ")", ")", "return", "inline_views" ]

[ "def", "all", "(", "self", ",", "page", "=", "None", ",", "per_page", "=", "None", ",", "include_totals", "=", "False", ",", "extra_params", "=", "None", ")", ":", "params", "=", "extra_params", "or", "{", "}", "params", ".", "update", "(", "{", "'page'", ":", "page", ",", "'per_page'", ":", "per_page", ",", "'include_totals'", ":", "str", "(", "include_totals", ")", ".", "lower", "(", ")", "}", ")", "return", "self", ".", "client", ".", "get", "(", "self", ".", "_url", "(", ")", ",", "params", "=", "params", ")" ]

[ "def", "mount_control_encode", "(", "self", ",", "target_system", ",", "target_component", ",", "input_a", ",", "input_b", ",", "input_c", ",", "save_position", ")", ":", "return", "MAVLink_mount_control_message", "(", "target_system", ",", "target_component", ",", "input_a", ",", "input_b", ",", "input_c", ",", "save_position", ")" ]

[ "def", "complete", "(", "self", ")", ":", "if", "None", "not", "in", "[", "v", "for", "v", "in", "self", ".", "squares", "]", ":", "return", "True", "if", "self", ".", "winner", "(", ")", "is", "not", "None", ":", "return", "True", "return", "False" ]

[ "def", "select", "(", "self", ",", "column", ",", "agg", "=", "None", ",", "_as", "=", "None", ",", "distinct", "=", "False", ")", ":", "if", "agg", "and", "not", "_as", ":", "raise", "ValueError", "(", "\"Aggregate colunns require `_as` to be specified\"", ")", "if", "column", "is", "False", ":", "self", ".", "_selects", "=", "{", "}", "else", ":", "self", ".", "_selects", ".", "setdefault", "(", "(", "_as", "or", "column", ")", ",", "(", "column", ",", "agg", ",", "_as", ",", "distinct", ")", ")" ]

[ "def", "human", "(", "value", ")", ":", "if", "value", ">=", "1073741824000", ":", "return", "'{:.1f} T'", ".", "format", "(", "value", "/", "1099511627776.0", ")", "if", "value", ">=", "1048576000", ":", "return", "'{:.1f} G'", ".", "format", "(", "value", "/", "1073741824.0", ")", "if", "value", ">=", "1024000", ":", "return", "'{:.1f} M'", ".", "format", "(", "value", "/", "1048576.0", ")", "if", "value", ">=", "1000", ":", "return", "'{:.1f} K'", ".", "format", "(", "value", "/", "1024.0", ")", "return", "'{} B'", ".", "format", "(", "value", ")" ]

[ "def", "wait_for_import_to_complete", "(", "self", ",", "import_id", ",", "region", "=", "'us-east-1'", ")", ":", "task_running", "=", "True", "while", "task_running", ":", "import_status_cmd", "=", "\"aws ec2 --profile {} --region '{}' --output 'json' describe-import-image-tasks --import-task-ids {}\"", ".", "format", "(", "self", ".", "aws_project", ",", "region", ",", "import_id", ")", "res", "=", "subprocess", ".", "check_output", "(", "shlex", ".", "split", "(", "import_status_cmd", ")", ")", "print", "\"Current status: {}\"", ".", "format", "(", "res", ")", "res_json", "=", "json", ".", "loads", "(", "res", ")", "task_running", ",", "image_id", "=", "self", ".", "check_task_status_and_id", "(", "res_json", ")" ]

[ "def", "GetParentFileEntry", "(", "self", ")", ":", "parent_location", "=", "None", "location", "=", "getattr", "(", "self", ".", "path_spec", ",", "'location'", ",", "None", ")", "if", "location", "is", "not", "None", ":", "parent_location", "=", "self", ".", "_file_system", ".", "DirnamePath", "(", "location", ")", "if", "parent_location", "==", "''", ":", "parent_location", "=", "self", ".", "_file_system", ".", "PATH_SEPARATOR", "parent_identifier", "=", "self", ".", "_fsapfs_file_entry", ".", "parent_identifier", "if", "parent_identifier", "is", "None", ":", "return", "None", "parent_path_spec", "=", "getattr", "(", "self", ".", "path_spec", ",", "'parent'", ",", "None", ")", "path_spec", "=", "apfs_path_spec", ".", "APFSPathSpec", "(", "location", "=", "parent_location", ",", "identifier", "=", "parent_identifier", ",", "parent", "=", "parent_path_spec", ")", "is_root", "=", "bool", "(", "parent_location", "==", "self", ".", "_file_system", ".", "LOCATION_ROOT", "or", "parent_identifier", "==", "self", ".", "_file_system", ".", "ROOT_DIRECTORY_IDENTIFIER", ")", "return", "APFSFileEntry", "(", "self", ".", "_resolver_context", ",", "self", ".", "_file_system", ",", "path_spec", ",", "is_root", "=", "is_root", ")" ]

[ "def", "build_common_all_meta_df", "(", "common_meta_dfs", ",", "fields_to_remove", ",", "remove_all_metadata_fields", ")", ":", "if", "remove_all_metadata_fields", ":", "trimmed_common_meta_dfs", "=", "[", "pd", ".", "DataFrame", "(", "index", "=", "df", ".", "index", ")", "for", "df", "in", "common_meta_dfs", "]", "else", ":", "shared_column_headers", "=", "sorted", "(", "set", ".", "intersection", "(", "*", "[", "set", "(", "df", ".", "columns", ")", "for", "df", "in", "common_meta_dfs", "]", ")", ")", "logger", ".", "debug", "(", "\"shared_column_headers: {}\"", ".", "format", "(", "shared_column_headers", ")", ")", "trimmed_common_meta_dfs", "=", "[", "df", "[", "shared_column_headers", "]", "for", "df", "in", "common_meta_dfs", "]", "# Remove any column headers that will prevent dfs from being identical", "for", "df", "in", "trimmed_common_meta_dfs", ":", "df", ".", "drop", "(", "fields_to_remove", ",", "axis", "=", "1", ",", "errors", "=", "\"ignore\"", ",", "inplace", "=", "True", ")", "# Concatenate all dfs and then remove duplicate rows", "all_meta_df_with_dups", "=", "pd", ".", "concat", "(", "trimmed_common_meta_dfs", ",", "axis", "=", "0", ")", "logger", ".", "debug", "(", "\"all_meta_df_with_dups.shape: {}\"", ".", "format", "(", "all_meta_df_with_dups", ".", "shape", ")", ")", "logger", ".", "debug", "(", "\"all_meta_df_with_dups.columns: {}\"", ".", "format", "(", "all_meta_df_with_dups", ".", "columns", ")", ")", "logger", ".", "debug", "(", "\"all_meta_df_with_dups.index: {}\"", ".", "format", "(", "all_meta_df_with_dups", ".", "index", ")", ")", "# If all metadata dfs were empty, df will be empty", "if", "all_meta_df_with_dups", ".", "empty", ":", "# Simply return unique ids", "all_meta_df", "=", "pd", ".", "DataFrame", "(", "index", "=", "all_meta_df_with_dups", ".", "index", ".", "unique", "(", ")", ")", "else", ":", "all_meta_df_with_dups", "[", "\"concat_column_for_index\"", "]", "=", "all_meta_df_with_dups", ".", "index", "all_meta_df", "=", "all_meta_df_with_dups", ".", "copy", "(", "deep", "=", "True", ")", ".", "drop_duplicates", "(", ")", "all_meta_df", ".", "drop", "(", "\"concat_column_for_index\"", ",", "axis", "=", "1", ",", "inplace", "=", "True", ")", "all_meta_df_with_dups", ".", "drop", "(", "\"concat_column_for_index\"", ",", "axis", "=", "1", ",", "inplace", "=", "True", ")", "logger", ".", "debug", "(", "\"all_meta_df_with_dups.shape: {}\"", ".", "format", "(", "all_meta_df_with_dups", ".", "shape", ")", ")", "logger", ".", "debug", "(", "\"all_meta_df.shape: {}\"", ".", "format", "(", "all_meta_df", ".", "shape", ")", ")", "return", "(", "all_meta_df", ",", "all_meta_df_with_dups", ")" ]

[ "def", "to_dict", "(", "self", ",", "include_null", "=", "True", ")", ":", "if", "include_null", ":", "return", "dict", "(", "self", ".", "items", "(", ")", ")", "else", ":", "return", "{", "attr", ":", "value", "for", "attr", ",", "value", "in", "self", ".", "__dict__", ".", "items", "(", ")", "if", "not", "attr", ".", "startswith", "(", "\"_sa_\"", ")", "}" ]

[ "def", "_set_trap", "(", "self", ",", "v", ",", "load", "=", "False", ")", ":", "if", "hasattr", "(", "v", ",", "\"_utype\"", ")", ":", "v", "=", "v", ".", "_utype", "(", "v", ")", "try", ":", "t", "=", "YANGDynClass", "(", "v", ",", "base", "=", "trap", ".", "trap", ",", "is_container", "=", "'container'", ",", "presence", "=", "False", ",", "yang_name", "=", "\"trap\"", ",", "rest_name", "=", "\"trap\"", ",", "parent", "=", "self", ",", "path_helper", "=", "self", ".", "_path_helper", ",", "extmethods", "=", "self", ".", "_extmethods", ",", "register_paths", "=", "True", ",", "extensions", "=", "{", "u'tailf-common'", ":", "{", "u'info'", ":", "u'Enable/Disable the traps.'", ",", "u'callpoint'", ":", "u'snmptraps'", "}", "}", ",", "namespace", "=", "'urn:brocade.com:mgmt:brocade-snmp'", ",", "defining_module", "=", "'brocade-snmp'", ",", "yang_type", "=", "'container'", ",", "is_config", "=", "True", ")", "except", "(", "TypeError", ",", "ValueError", ")", ":", "raise", "ValueError", "(", "{", "'error-string'", ":", "\"\"\"trap must be of a type compatible with container\"\"\"", ",", "'defined-type'", ":", "\"container\"", ",", "'generated-type'", ":", "\"\"\"YANGDynClass(base=trap.trap, is_container='container', presence=False, yang_name=\"trap\", rest_name=\"trap\", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'tailf-common': {u'info': u'Enable/Disable the traps.', u'callpoint': u'snmptraps'}}, namespace='urn:brocade.com:mgmt:brocade-snmp', defining_module='brocade-snmp', yang_type='container', is_config=True)\"\"\"", ",", "}", ")", "self", ".", "__trap", "=", "t", "if", "hasattr", "(", "self", ",", "'_set'", ")", ":", "self", ".", "_set", "(", ")" ]

[ "def", "paintEvent", "(", "self", ",", "event", ")", ":", "def", "__set_bold", "(", "state", ")", ":", "\"\"\"\n Sets the current painter font bold state.\n\n :return: Definiton success.\n :rtype: bool\n \"\"\"", "font", "=", "painter", ".", "font", "(", ")", "font", ".", "setBold", "(", "state", ")", "painter", ".", "setFont", "(", "font", ")", "return", "True", "painter", "=", "QPainter", "(", "self", ")", "painter", ".", "fillRect", "(", "event", ".", "rect", "(", ")", ",", "self", ".", "__background_color", ")", "pen", "=", "QPen", "(", "QBrush", "(", ")", ",", "self", ".", "__separator_width", ")", "pen", ".", "setColor", "(", "self", ".", "__separator_color", ")", "painter", ".", "setPen", "(", "pen", ")", "top_right_corner", "=", "event", ".", "rect", "(", ")", ".", "topRight", "(", ")", "bottom_right_corner", "=", "event", ".", "rect", "(", ")", ".", "bottomRight", "(", ")", "painter", ".", "drawLine", "(", "top_right_corner", ".", "x", "(", ")", ",", "top_right_corner", ".", "y", "(", ")", ",", "bottom_right_corner", ".", "x", "(", ")", ",", "bottom_right_corner", ".", "y", "(", ")", ")", "painter", ".", "setPen", "(", "self", ".", "__color", ")", "viewport_height", "=", "self", ".", "__editor", ".", "viewport", "(", ")", ".", "height", "(", ")", "metrics", "=", "QFontMetrics", "(", "self", ".", "__editor", ".", "document", "(", ")", ".", "defaultFont", "(", ")", ")", "current_block", "=", "self", ".", "__editor", ".", "document", "(", ")", ".", "findBlock", "(", "self", ".", "__editor", ".", "textCursor", "(", ")", ".", "position", "(", ")", ")", "block", "=", "self", ".", "__editor", ".", "firstVisibleBlock", "(", ")", "block_number", "=", "block", ".", "blockNumber", "(", ")", "painter", ".", "setFont", "(", "self", ".", "__editor", ".", "document", "(", ")", ".", "defaultFont", "(", ")", ")", "while", "block", ".", "isValid", "(", ")", ":", "block_number", "+=", "1", "position", "=", "self", ".", "__editor", ".", "blockBoundingGeometry", "(", "block", ")", ".", "topLeft", "(", ")", "+", "self", ".", "__editor", ".", "contentOffset", "(", ")", "if", "position", ".", "y", "(", ")", ">", "viewport_height", ":", "break", "if", "not", "block", ".", "isVisible", "(", ")", ":", "continue", "block", "==", "current_block", "and", "__set_bold", "(", "True", ")", "or", "__set_bold", "(", "False", ")", "painter", ".", "drawText", "(", "self", ".", "width", "(", ")", "-", "metrics", ".", "width", "(", "foundations", ".", "strings", ".", "to_string", "(", "block_number", ")", ")", "-", "self", ".", "__margin", "/", "3", ",", "round", "(", "position", ".", "y", "(", ")", "+", "metrics", ".", "ascent", "(", ")", "+", "metrics", ".", "descent", "(", ")", "-", "(", "self", ".", "__editor", ".", "blockBoundingRect", "(", "block", ")", ".", "height", "(", ")", "*", "8.0", "/", "100", ")", ")", ",", "foundations", ".", "strings", ".", "to_string", "(", "block_number", ")", ")", "block", "=", "block", ".", "next", "(", ")", "painter", ".", "end", "(", ")", "QWidget", ".", "paintEvent", "(", "self", ",", "event", ")" ]

[ "def", "channels_voice_greeting_category_show", "(", "self", ",", "id", ",", "*", "*", "kwargs", ")", ":", "api_path", "=", "\"/api/v2/channels/voice/greeting_categories/{id}.json\"", "api_path", "=", "api_path", ".", "format", "(", "id", "=", "id", ")", "return", "self", ".", "call", "(", "api_path", ",", "*", "*", "kwargs", ")" ]

[ "def", "dump", "(", "self", ",", "filename", ")", ":", "with", "open", "(", "filename", ",", "\"w\"", ")", "as", "f", ":", "for", "name", "in", "sorted", "(", "self", ".", "_fields", ")", ":", "self", ".", "_fields", "[", "name", "]", ".", "dump", "(", "f", ",", "name", ")" ]

[ "def", "_onSelectItem", "(", "self", ",", "selection", ",", "previousSelection", ")", ":", "self", ".", "_acceptButton", ".", "setEnabled", "(", "True", ")", "del", "self", ".", "_selected", "[", ":", "]", "item", "=", "self", ".", "_filesystemWidget", ".", "model", "(", ")", ".", "item", "(", "selection", ")", "self", ".", "_selected", ".", "append", "(", "item", ".", "path", ")" ]

[ "def", "parsed_file", "(", "config_file", ")", ":", "parser", "=", "ConfigParser", "(", "allow_no_value", "=", "True", ")", "parser", ".", "readfp", "(", "config_file", ")", "return", "parser" ]

[ "def", "set_bool_param", "(", "params", ",", "name", ",", "value", ")", ":", "if", "value", "is", "None", ":", "return", "if", "value", "is", "True", ":", "params", "[", "name", "]", "=", "'true'", "elif", "value", "is", "False", ":", "params", "[", "name", "]", "=", "'false'", "else", ":", "raise", "ValueError", "(", "\"Parameter '%s' must be boolean or None, got %r.\"", "%", "(", "name", ",", "value", ")", ")" ]

[ "def", "segwit_addr_decode", "(", "addr", ",", "hrp", "=", "bech32_prefix", ")", ":", "hrpgot", ",", "data", "=", "bech32_decode", "(", "addr", ")", "if", "hrpgot", "!=", "hrp", ":", "return", "(", "None", ",", "None", ")", "decoded", "=", "convertbits", "(", "data", "[", "1", ":", "]", ",", "5", ",", "8", ",", "False", ")", "if", "decoded", "is", "None", "or", "len", "(", "decoded", ")", "<", "2", "or", "len", "(", "decoded", ")", ">", "40", ":", "return", "(", "None", ",", "None", ")", "if", "data", "[", "0", "]", ">", "16", ":", "return", "(", "None", ",", "None", ")", "if", "data", "[", "0", "]", "==", "0", "and", "len", "(", "decoded", ")", "!=", "20", "and", "len", "(", "decoded", ")", "!=", "32", ":", "return", "(", "None", ",", "None", ")", "return", "(", "data", "[", "0", "]", ",", "''", ".", "join", "(", "[", "chr", "(", "x", ")", "for", "x", "in", "decoded", "]", ")", ")" ]

[ "def", "uniform_grid", "(", "min_pt", ",", "max_pt", ",", "shape", ",", "nodes_on_bdry", "=", "True", ")", ":", "return", "uniform_grid_fromintv", "(", "IntervalProd", "(", "min_pt", ",", "max_pt", ")", ",", "shape", ",", "nodes_on_bdry", "=", "nodes_on_bdry", ")" ]

[ "def", "apply_diff", "(", "text", ",", "diff", ",", "reverse", "=", "False", ",", "verify", "=", "True", ")", ":", "if", "not", "diff", ":", "return", "text", "output", "=", "text", "hunks", "=", "[", "(", "new_diff", "[", "start_hunk", "]", ",", "new_diff", "[", "start_hunk", "+", "1", ":", "end_hunk", "]", ")", "for", "new_diff", "in", "[", "[", "d", ".", "lstrip", "(", ")", "for", "d", "in", "diff", "if", "d", ".", "lstrip", "(", ")", "and", "d", "!=", "\"\\\\ No newline at end of file\"", "]", "+", "[", "\"@@\"", "]", "]", "# ANOTHER REPAIR", "for", "start_hunk", ",", "end_hunk", "in", "pairwise", "(", "i", "for", "i", ",", "l", "in", "enumerate", "(", "new_diff", ")", "if", "l", ".", "startswith", "(", "'@@'", ")", ")", "]", "for", "header", ",", "hunk_body", "in", "(", "reversed", "(", "hunks", ")", "if", "reverse", "else", "hunks", ")", ":", "matches", "=", "DIFF_PREFIX", ".", "match", "(", "header", ".", "strip", "(", ")", ")", "if", "not", "matches", ":", "if", "not", "_Log", ":", "_late_import", "(", ")", "_Log", ".", "error", "(", "\"Can not handle \\n---\\n{{diff}}\\n---\\n\"", ",", "diff", "=", "diff", ")", "removes", "=", "tuple", "(", "int", "(", "i", ".", "strip", "(", ")", ")", "for", "i", "in", "matches", ".", "group", "(", "1", ")", ".", "split", "(", "\",\"", ")", ")", "# EXPECTING start_line, length TO REMOVE", "remove", "=", "Data", "(", "start", "=", "removes", "[", "0", "]", ",", "length", "=", "1", "if", "len", "(", "removes", ")", "==", "1", "else", "removes", "[", "1", "]", ")", "# ASSUME FIRST LINE", "adds", "=", "tuple", "(", "int", "(", "i", ".", "strip", "(", ")", ")", "for", "i", "in", "matches", ".", "group", "(", "2", ")", ".", "split", "(", "\",\"", ")", ")", "# EXPECTING start_line, length TO ADD", "add", "=", "Data", "(", "start", "=", "adds", "[", "0", "]", ",", "length", "=", "1", "if", "len", "(", "adds", ")", "==", "1", "else", "adds", "[", "1", "]", ")", "if", "add", ".", "length", "==", "0", "and", "add", ".", "start", "==", "0", ":", "add", ".", "start", "=", "remove", ".", "start", "def", "repair_hunk", "(", "hunk_body", ")", ":", "# THE LAST DELETED LINE MAY MISS A \"\\n\" MEANING THE FIRST", "# ADDED LINE WILL BE APPENDED TO THE LAST DELETED LINE", "# EXAMPLE: -kward has the details.+kward has the details.", "# DETECT THIS PROBLEM FOR THIS HUNK AND FIX THE DIFF", "if", "reverse", ":", "last_lines", "=", "[", "o", "for", "b", ",", "o", "in", "zip", "(", "reversed", "(", "hunk_body", ")", ",", "reversed", "(", "output", ")", ")", "if", "b", "!=", "\"+\"", "+", "o", "]", "if", "not", "last_lines", ":", "return", "hunk_body", "last_line", "=", "last_lines", "[", "0", "]", "for", "problem_index", ",", "problem_line", "in", "enumerate", "(", "hunk_body", ")", ":", "if", "problem_line", ".", "startswith", "(", "'-'", ")", "and", "problem_line", ".", "endswith", "(", "'+'", "+", "last_line", ")", ":", "split_point", "=", "len", "(", "problem_line", ")", "-", "(", "len", "(", "last_line", ")", "+", "1", ")", "break", "elif", "problem_line", ".", "startswith", "(", "'+'", "+", "last_line", "+", "\"-\"", ")", ":", "split_point", "=", "len", "(", "last_line", ")", "+", "1", "break", "else", ":", "return", "hunk_body", "else", ":", "if", "not", "output", ":", "return", "hunk_body", "last_line", "=", "output", "[", "-", "1", "]", "for", "problem_index", ",", "problem_line", "in", "enumerate", "(", "hunk_body", ")", ":", "if", "problem_line", ".", "startswith", "(", "'+'", ")", "and", "problem_line", ".", "endswith", "(", "'-'", "+", "last_line", ")", ":", "split_point", "=", "len", "(", "problem_line", ")", "-", "(", "len", "(", "last_line", ")", "+", "1", ")", "break", "elif", "problem_line", ".", "startswith", "(", "'-'", "+", "last_line", "+", "\"+\"", ")", ":", "split_point", "=", "len", "(", "last_line", ")", "+", "1", "break", "else", ":", "return", "hunk_body", "new_hunk_body", "=", "(", "hunk_body", "[", ":", "problem_index", "]", "+", "[", "problem_line", "[", ":", "split_point", "]", ",", "problem_line", "[", "split_point", ":", "]", "]", "+", "hunk_body", "[", "problem_index", "+", "1", ":", "]", ")", "return", "new_hunk_body", "hunk_body", "=", "repair_hunk", "(", "hunk_body", ")", "if", "reverse", ":", "new_output", "=", "(", "output", "[", ":", "add", ".", "start", "-", "1", "]", "+", "[", "d", "[", "1", ":", "]", "for", "d", "in", "hunk_body", "if", "d", "and", "d", "[", "0", "]", "==", "'-'", "]", "+", "output", "[", "add", ".", "start", "+", "add", ".", "length", "-", "1", ":", "]", ")", "else", ":", "new_output", "=", "(", "output", "[", ":", "add", ".", "start", "-", "1", "]", "+", "[", "d", "[", "1", ":", "]", "for", "d", "in", "hunk_body", "if", "d", "and", "d", "[", "0", "]", "==", "'+'", "]", "+", "output", "[", "add", ".", "start", "+", "remove", ".", "length", "-", "1", ":", "]", ")", "output", "=", "new_output", "if", "verify", ":", "original", "=", "apply_diff", "(", "output", ",", "diff", ",", "not", "reverse", ",", "False", ")", "if", "set", "(", "text", ")", "!=", "set", "(", "original", ")", ":", "# bugzilla-etl diffs are a jumble", "for", "t", ",", "o", "in", "zip_longest", "(", "text", ",", "original", ")", ":", "if", "t", "in", "[", "'reports: https://goo.gl/70o6w6\\r'", "]", ":", "break", "# KNOWN INCONSISTENCIES", "if", "t", "!=", "o", ":", "if", "not", "_Log", ":", "_late_import", "(", ")", "_Log", ".", "error", "(", "\"logical verification check failed\"", ")", "break", "return", "output" ]

[ "def", "get_jvm_options", "(", "self", ")", ":", "ret", "=", "[", "]", "for", "opt", "in", "self", ".", "get_options", "(", ")", ".", "options", ":", "ret", ".", "extend", "(", "safe_shlex_split", "(", "opt", ")", ")", "if", "(", "self", ".", "get_options", "(", ")", ".", "debug", "or", "self", ".", "get_options", "(", ")", ".", "is_flagged", "(", "'debug_port'", ")", "or", "self", ".", "get_options", "(", ")", ".", "is_flagged", "(", "'debug_args'", ")", ")", ":", "debug_port", "=", "self", ".", "get_options", "(", ")", ".", "debug_port", "ret", ".", "extend", "(", "arg", ".", "format", "(", "debug_port", "=", "debug_port", ")", "for", "arg", "in", "self", ".", "get_options", "(", ")", ".", "debug_args", ")", "return", "ret" ]

[ "def", "from_text", "(", "cls", ",", "text", ":", "str", ")", ":", "eidosProcessor", "=", "process_text", "(", "text", ")", "return", "cls", ".", "from_statements", "(", "eidosProcessor", ".", "statements", ")" ]

[ "def", "geocode", "(", "self", ",", "query", ",", "exactly_one", "=", "True", ",", "timeout", "=", "DEFAULT_SENTINEL", ",", "candidates", "=", "None", ",", "# TODO: change default value to `1` in geopy 2.0", ")", ":", "if", "candidates", "is", "None", ":", "candidates", "=", "self", ".", "candidates", "if", "candidates", "is", "None", ":", "candidates", "=", "1", "# TODO: move to default args in geopy 2.0.", "if", "candidates", ":", "if", "not", "(", "1", "<=", "candidates", "<=", "10", ")", ":", "raise", "ValueError", "(", "'candidates must be between 1 and 10'", ")", "query", "=", "{", "'auth-id'", ":", "self", ".", "auth_id", ",", "'auth-token'", ":", "self", ".", "auth_token", ",", "'street'", ":", "self", ".", "format_string", "%", "query", ",", "'candidates'", ":", "candidates", ",", "}", "url", "=", "'{url}?{query}'", ".", "format", "(", "url", "=", "self", ".", "api", ",", "query", "=", "urlencode", "(", "query", ")", ")", "logger", ".", "debug", "(", "\"%s.geocode: %s\"", ",", "self", ".", "__class__", ".", "__name__", ",", "url", ")", "return", "self", ".", "_parse_json", "(", "self", ".", "_call_geocoder", "(", "url", ",", "timeout", "=", "timeout", ")", ",", "exactly_one", ")" ]

[ "def", "_get_action_name", "(", "self", ",", "items", "=", "None", ",", "past", "=", "False", ")", ":", "action_type", "=", "\"past\"", "if", "past", "else", "\"present\"", "if", "items", "is", "None", ":", "# Called without items parameter (by a single instance.)", "count", "=", "1", "else", ":", "count", "=", "len", "(", "items", ")", "action_attr", "=", "getattr", "(", "self", ",", "\"action_%s\"", "%", "action_type", ")", "(", "count", ")", "if", "isinstance", "(", "action_attr", ",", "(", "six", ".", "string_types", ",", "Promise", ")", ")", ":", "action", "=", "action_attr", "else", ":", "toggle_selection", "=", "getattr", "(", "self", ",", "\"current_%s_action\"", "%", "action_type", ")", "action", "=", "action_attr", "[", "toggle_selection", "]", "return", "action" ]

[ "def", "exists", "(", ")", ":", "if", "env", "(", ")", ":", "cij", ".", "err", "(", "\"cij.nvm.exists: Invalid NVMe ENV.\"", ")", "return", "1", "nvm", "=", "cij", ".", "env_to_dict", "(", "PREFIX", ",", "EXPORTED", "+", "REQUIRED", ")", "cmd", "=", "[", "'[[ -b \"%s\" ]]'", "%", "nvm", "[", "\"DEV_PATH\"", "]", "]", "rcode", ",", "_", ",", "_", "=", "cij", ".", "ssh", ".", "command", "(", "cmd", ",", "shell", "=", "True", ",", "echo", "=", "False", ")", "return", "rcode" ]

[ "def", "parse", "(", "code", ",", "mode", "=", "'exec'", ",", "*", "*", "exception_kwargs", ")", ":", "try", ":", "return", "_ast_util", ".", "parse", "(", "code", ",", "'<unknown>'", ",", "mode", ")", "except", "Exception", ":", "raise", "exceptions", ".", "SyntaxException", "(", "\"(%s) %s (%r)\"", "%", "(", "compat", ".", "exception_as", "(", ")", ".", "__class__", ".", "__name__", ",", "compat", ".", "exception_as", "(", ")", ",", "code", "[", "0", ":", "50", "]", ")", ",", "*", "*", "exception_kwargs", ")" ]

[ "def", "read_boolean_option", "(", "self", ",", "section", ",", "option", ")", ":", "if", "self", ".", "has_option", "(", "section", ",", "option", ")", ":", "self", ".", "config", "[", "option", "]", "=", "self", ".", "getboolean", "(", "section", ",", "option", ")" ]

[ "def", "quast_predicted_genes_barplot", "(", "self", ")", ":", "# Prep the data", "# extract the ranges given to quast with \"--gene-thresholds\"", "prefix", "=", "'# predicted genes (>= '", "suffix", "=", "' bp)'", "all_thresholds", "=", "sorted", "(", "list", "(", "set", "(", "[", "int", "(", "key", "[", "len", "(", "prefix", ")", ":", "-", "len", "(", "suffix", ")", "]", ")", "for", "_", ",", "d", "in", "self", ".", "quast_data", ".", "items", "(", ")", "for", "key", "in", "d", ".", "keys", "(", ")", "if", "key", ".", "startswith", "(", "prefix", ")", "]", ")", ")", ")", "data", "=", "{", "}", "ourpat", "=", "'>= {}{} bp'", "theirpat", "=", "prefix", "+", "\"{}\"", "+", "suffix", "for", "s_name", ",", "d", "in", "self", ".", "quast_data", ".", "items", "(", ")", ":", "thresholds", "=", "sorted", "(", "list", "(", "set", "(", "[", "int", "(", "key", "[", "len", "(", "prefix", ")", ":", "-", "len", "(", "suffix", ")", "]", ")", "for", "_", ",", "x", "in", "self", ".", "quast_data", ".", "items", "(", ")", "for", "key", "in", "x", ".", "keys", "(", ")", "if", "key", ".", "startswith", "(", "prefix", ")", "]", ")", ")", ")", "if", "len", "(", "thresholds", ")", "<", "2", ":", "continue", "p", "=", "dict", "(", ")", "try", ":", "p", "=", "{", "ourpat", ".", "format", "(", "thresholds", "[", "-", "1", "]", ",", "\"\"", ")", ":", "d", "[", "theirpat", ".", "format", "(", "thresholds", "[", "-", "1", "]", ")", "]", "}", "for", "low", ",", "high", "in", "zip", "(", "thresholds", "[", ":", "-", "1", "]", ",", "thresholds", "[", "1", ":", "]", ")", ":", "p", "[", "ourpat", ".", "format", "(", "low", ",", "-", "high", ")", "]", "=", "d", "[", "theirpat", ".", "format", "(", "low", ")", "]", "-", "d", "[", "theirpat", ".", "format", "(", "high", ")", "]", "assert", "sum", "(", "p", ".", "values", "(", ")", ")", "==", "d", "[", "theirpat", ".", "format", "(", "0", ")", "]", "except", "AssertionError", ":", "log", ".", "warning", "(", "\"Predicted gene counts didn't add up properly for \\\"{}\\\"\"", ".", "format", "(", "s_name", ")", ")", "except", "KeyError", ":", "log", ".", "warning", "(", "\"Not all predicted gene thresholds available for \\\"{}\\\"\"", ".", "format", "(", "s_name", ")", ")", "data", "[", "s_name", "]", "=", "p", "cats", "=", "[", "ourpat", ".", "format", "(", "low", ",", "-", "high", "if", "high", "else", "\"\"", ")", "for", "low", ",", "high", "in", "zip", "(", "all_thresholds", ",", "all_thresholds", "[", "1", ":", "]", "+", "[", "None", "]", ")", "]", "if", "len", "(", "cats", ")", ">", "0", ":", "return", "bargraph", ".", "plot", "(", "data", ",", "cats", ",", "{", "'id'", ":", "'quast_predicted_genes'", ",", "'title'", ":", "'QUAST: Number of predicted genes'", ",", "'ylab'", ":", "'Number of predicted genes'", "}", ")", "else", ":", "return", "None" ]

[ "def", "match_to_dict", "(", "match", ")", ":", "balance", ",", "indent", ",", "account_fragment", "=", "match", ".", "group", "(", "1", ",", "2", ",", "3", ")", "return", "{", "'balance'", ":", "decimal", ".", "Decimal", "(", "balance", ")", ",", "'indent'", ":", "len", "(", "indent", ")", ",", "'account_fragment'", ":", "account_fragment", ",", "'parent'", ":", "None", ",", "'children'", ":", "[", "]", ",", "}" ]

[ "def", "explode", "(", "col", ")", ":", "sc", "=", "SparkContext", ".", "_active_spark_context", "jc", "=", "sc", ".", "_jvm", ".", "functions", ".", "explode", "(", "_to_java_column", "(", "col", ")", ")", "return", "Column", "(", "jc", ")" ]

[ "def", "extract_keyhandle", "(", "path", ",", "filepath", ")", ":", "keyhandle", "=", "filepath", ".", "lstrip", "(", "path", ")", "keyhandle", "=", "keyhandle", ".", "split", "(", "\"/\"", ")", "return", "keyhandle", "[", "0", "]" ]

[ "def", "set_app_args", "(", "self", ",", "*", "args", ")", ":", "if", "args", ":", "self", ".", "_set", "(", "'pyargv'", ",", "' '", ".", "join", "(", "args", ")", ")", "return", "self", ".", "_section" ]