Datasets:

---

kejian

/

codesearchnet-python-raw

like 1

[ "def", "_get_ericscript_path", "(", "self", ")", ":", "es", "=", "utils", ".", "which", "(", "os", ".", "path", ".", "join", "(", "utils", ".", "get_bcbio_bin", "(", ")", ",", "self", ".", "EXECUTABLE", ")", ")", "return", "os", ".", "path", ".", "dirname", "(", "os", ".", "path", ".", "realpath", "(", "es", ")", ")" ]

[ "Retrieve", "PATH", "to", "the", "isolated", "eriscript", "anaconda", "environment", "." ]

[ "def", "encoded_length", "(", "self", ",", "num_bytes", "=", "16", ")", ":", "factor", "=", "math", ".", "log", "(", "256", ")", "/", "math", ".", "log", "(", "self", ".", "_alpha_len", ")", "return", "int", "(", "math", ".", "ceil", "(", "factor", "*", "num_bytes", ")", ")" ]

[ "Returns", "the", "string", "length", "of", "the", "shortened", "UUID", "." ]

[ "def", "one_hot2string", "(", "arr", ",", "vocab", ")", ":", "tokens", "=", "one_hot2token", "(", "arr", ")", "indexToLetter", "=", "_get_index_dict", "(", "vocab", ")", "return", "[", "''", ".", "join", "(", "[", "indexToLetter", "[", "x", "]", "for", "x", "in", "row", "]", ")", "for", "row", "in", "tokens", "]" ]

[ "Convert", "a", "one", "-", "hot", "encoded", "array", "back", "to", "string" ]

[ "def", "alias", "(", "self", ",", "annotationtype", ",", "set", ",", "fallback", "=", "False", ")", ":", "if", "inspect", ".", "isclass", "(", "annotationtype", ")", ":", "annotationtype", "=", "annotationtype", ".", "ANNOTATIONTYPE", "if", "annotationtype", "in", "self", ".", "set_alias", "and", "set", "in", "self", ".", "set_alias", "[", "annotationtype", "]", ":", "return", "self", ".", "set_alias", "[", "annotationtype", "]", "[", "set", "]", "elif", "fallback", ":", "return", "set", "else", ":", "raise", "KeyError", "(", "\"No alias for set \"", "+", "set", ")" ]

[ "Return", "the", "alias", "for", "a", "set", "(", "if", "applicable", "returns", "the", "unaltered", "set", "otherwise", "iff", "fallback", "is", "enabled", ")" ]

[ "def", "get_iam_policy", "(", "self", ",", "client", "=", "None", ")", ":", "client", "=", "self", ".", "_require_client", "(", "client", ")", "query_params", "=", "{", "}", "if", "self", ".", "user_project", "is", "not", "None", ":", "query_params", "[", "\"userProject\"", "]", "=", "self", ".", "user_project", "info", "=", "client", ".", "_connection", ".", "api_request", "(", "method", "=", "\"GET\"", ",", "path", "=", "\"%s/iam\"", "%", "(", "self", ".", "path", ",", ")", ",", "query_params", "=", "query_params", ",", "_target_object", "=", "None", ",", ")", "return", "Policy", ".", "from_api_repr", "(", "info", ")" ]

[ "Retrieve", "the", "IAM", "policy", "for", "the", "bucket", "." ]

[ "def", "_to_dict", "(", "self", ")", ":", "_dict", "=", "{", "}", "if", "hasattr", "(", "self", ",", "'customizations'", ")", "and", "self", ".", "customizations", "is", "not", "None", ":", "_dict", "[", "'customizations'", "]", "=", "[", "x", ".", "_to_dict", "(", ")", "for", "x", "in", "self", ".", "customizations", "]", "return", "_dict" ]

[ "Return", "a", "json", "dictionary", "representing", "this", "model", "." ]

[ "def", "resize", "(", "self", ",", "nrows", ",", "front", "=", "False", ")", ":", "nrows_current", "=", "self", ".", "get_nrows", "(", ")", "if", "nrows", "==", "nrows_current", ":", "return", "if", "nrows", "<", "nrows_current", ":", "rowdiff", "=", "nrows_current", "-", "nrows", "if", "front", ":", "# delete from the front", "start", "=", "0", "stop", "=", "rowdiff", "else", ":", "# delete from the back", "start", "=", "nrows", "stop", "=", "nrows_current", "self", ".", "delete_rows", "(", "slice", "(", "start", ",", "stop", ")", ")", "else", ":", "rowdiff", "=", "nrows", "-", "nrows_current", "if", "front", ":", "# in this case zero is what we want, since the code inserts", "firstrow", "=", "0", "else", ":", "firstrow", "=", "nrows_current", "self", ".", "_FITS", ".", "insert_rows", "(", "self", ".", "_ext", "+", "1", ",", "firstrow", ",", "rowdiff", ")", "self", ".", "_update_info", "(", ")" ]

[ "Resize", "the", "table", "to", "the", "given", "size", "removing", "or", "adding", "rows", "as", "necessary", ".", "Note", "if", "expanding", "the", "table", "at", "the", "end", "it", "is", "more", "efficient", "to", "use", "the", "append", "function", "than", "resizing", "and", "then", "writing", "." ]

[ "def", "report", "(", "config", ",", "path", ",", "metrics", ",", "n", ",", "output", ",", "include_message", "=", "False", ",", "format", "=", "ReportFormat", ".", "CONSOLE", ",", "console_format", "=", "None", ",", ")", ":", "logger", ".", "debug", "(", "\"Running report command\"", ")", "logger", ".", "info", "(", "f\"-----------History for {metrics}------------\"", ")", "data", "=", "[", "]", "metric_metas", "=", "[", "]", "for", "metric", "in", "metrics", ":", "operator", ",", "metric", "=", "resolve_metric_as_tuple", "(", "metric", ")", "key", "=", "metric", ".", "name", "operator", "=", "operator", ".", "name", "# Set the delta colors depending on the metric type", "if", "metric", ".", "measure", "==", "MetricType", ".", "AimHigh", ":", "good_color", "=", "32", "bad_color", "=", "31", "elif", "metric", ".", "measure", "==", "MetricType", ".", "AimLow", ":", "good_color", "=", "31", "bad_color", "=", "32", "elif", "metric", ".", "measure", "==", "MetricType", ".", "Informational", ":", "good_color", "=", "33", "bad_color", "=", "33", "metric_meta", "=", "{", "\"key\"", ":", "key", ",", "\"operator\"", ":", "operator", ",", "\"good_color\"", ":", "good_color", ",", "\"bad_color\"", ":", "bad_color", ",", "\"title\"", ":", "metric", ".", "description", ",", "\"type\"", ":", "metric", ".", "type", ",", "}", "metric_metas", ".", "append", "(", "metric_meta", ")", "state", "=", "State", "(", "config", ")", "for", "archiver", "in", "state", ".", "archivers", ":", "# We have to do it backwards to get the deltas between releases", "history", "=", "state", ".", "index", "[", "archiver", "]", ".", "revisions", "[", ":", "n", "]", "[", ":", ":", "-", "1", "]", "last", "=", "{", "}", "for", "rev", "in", "history", ":", "vals", "=", "[", "]", "for", "meta", "in", "metric_metas", ":", "try", ":", "logger", ".", "debug", "(", "f\"Fetching metric {meta['key']} for {meta['operator']} in {path}\"", ")", "val", "=", "rev", ".", "get", "(", "config", ",", "archiver", ",", "meta", "[", "\"operator\"", "]", ",", "path", ",", "meta", "[", "\"key\"", "]", ")", "last_val", "=", "last", ".", "get", "(", "meta", "[", "\"key\"", "]", ",", "None", ")", "# Measure the difference between this value and the last", "if", "meta", "[", "\"type\"", "]", "in", "(", "int", ",", "float", ")", ":", "if", "last_val", ":", "delta", "=", "val", "-", "last_val", "else", ":", "delta", "=", "0", "last", "[", "meta", "[", "\"key\"", "]", "]", "=", "val", "else", ":", "# TODO : Measure ranking increases/decreases for str types?", "delta", "=", "0", "if", "delta", "==", "0", ":", "delta_col", "=", "delta", "elif", "delta", "<", "0", ":", "delta_col", "=", "f\"\\u001b[{meta['good_color']}m{delta:n}\\u001b[0m\"", "else", ":", "delta_col", "=", "f\"\\u001b[{meta['bad_color']}m+{delta:n}\\u001b[0m\"", "if", "meta", "[", "\"type\"", "]", "in", "(", "int", ",", "float", ")", ":", "k", "=", "f\"{val:n} ({delta_col})\"", "else", ":", "k", "=", "f\"{val}\"", "except", "KeyError", "as", "e", ":", "k", "=", "f\"Not found {e}\"", "vals", ".", "append", "(", "k", ")", "if", "include_message", ":", "data", ".", "append", "(", "(", "format_revision", "(", "rev", ".", "revision", ".", "key", ")", ",", "rev", ".", "revision", ".", "message", "[", ":", "MAX_MESSAGE_WIDTH", "]", ",", "rev", ".", "revision", ".", "author_name", ",", "format_date", "(", "rev", ".", "revision", ".", "date", ")", ",", "*", "vals", ",", ")", ")", "else", ":", "data", ".", "append", "(", "(", "format_revision", "(", "rev", ".", "revision", ".", "key", ")", ",", "rev", ".", "revision", ".", "author_name", ",", "format_date", "(", "rev", ".", "revision", ".", "date", ")", ",", "*", "vals", ",", ")", ")", "descriptions", "=", "[", "meta", "[", "\"title\"", "]", "for", "meta", "in", "metric_metas", "]", "if", "include_message", ":", "headers", "=", "(", "\"Revision\"", ",", "\"Message\"", ",", "\"Author\"", ",", "\"Date\"", ",", "*", "descriptions", ")", "else", ":", "headers", "=", "(", "\"Revision\"", ",", "\"Author\"", ",", "\"Date\"", ",", "*", "descriptions", ")", "if", "format", "==", "ReportFormat", ".", "HTML", ":", "if", "output", ".", "is_file", "and", "output", ".", "suffix", "==", "\".html\"", ":", "report_path", "=", "output", ".", "parents", "[", "0", "]", "report_output", "=", "output", "else", ":", "report_path", "=", "output", "report_output", "=", "output", ".", "joinpath", "(", "\"index.html\"", ")", "report_path", ".", "mkdir", "(", "exist_ok", "=", "True", ",", "parents", "=", "True", ")", "templates_dir", "=", "(", "Path", "(", "__file__", ")", ".", "parents", "[", "1", "]", "/", "\"templates\"", ")", ".", "resolve", "(", ")", "report_template", "=", "Template", "(", "(", "templates_dir", "/", "\"report_template.html\"", ")", ".", "read_text", "(", ")", ")", "table_headers", "=", "\"\"", ".", "join", "(", "[", "f\"<th>{header}</th>\"", "for", "header", "in", "headers", "]", ")", "table_content", "=", "\"\"", "for", "line", "in", "data", "[", ":", ":", "-", "1", "]", ":", "table_content", "+=", "\"<tr>\"", "for", "element", "in", "line", ":", "element", "=", "element", ".", "replace", "(", "\"[32m\"", ",", "\"<span class='green-color'>\"", ")", "element", "=", "element", ".", "replace", "(", "\"[31m\"", ",", "\"<span class='red-color'>\"", ")", "element", "=", "element", ".", "replace", "(", "\"[33m\"", ",", "\"<span class='orange-color'>\"", ")", "element", "=", "element", ".", "replace", "(", "\"[0m\"", ",", "\"</span>\"", ")", "table_content", "+=", "f\"<td>{element}</td>\"", "table_content", "+=", "\"</tr>\"", "report_template", "=", "report_template", ".", "safe_substitute", "(", "headers", "=", "table_headers", ",", "content", "=", "table_content", ")", "with", "report_output", ".", "open", "(", "\"w\"", ")", "as", "output", ":", "output", ".", "write", "(", "report_template", ")", "try", ":", "copytree", "(", "str", "(", "templates_dir", "/", "\"css\"", ")", ",", "str", "(", "report_path", "/", "\"css\"", ")", ")", "except", "FileExistsError", ":", "pass", "logger", ".", "info", "(", "f\"wily report was saved to {report_path}\"", ")", "else", ":", "print", "(", "# But it still makes more sense to show the newest at the top, so reverse again", "tabulate", ".", "tabulate", "(", "headers", "=", "headers", ",", "tabular_data", "=", "data", "[", ":", ":", "-", "1", "]", ",", "tablefmt", "=", "console_format", ")", ")" ]

[ "Show", "information", "about", "the", "cache", "and", "runtime", "." ]

[ "def", "goes_requires", "(", "self", ",", "regs", ")", ":", "if", "len", "(", "self", ")", "and", "self", ".", "mem", "[", "-", "1", "]", ".", "inst", "==", "'call'", "and", "self", ".", "mem", "[", "-", "1", "]", ".", "condition_flag", "is", "None", ":", "for", "block", "in", "self", ".", "calls", ":", "if", "block", ".", "is_used", "(", "regs", ",", "0", ")", ":", "return", "True", "d", "=", "block", ".", "destroys", "(", ")", "if", "not", "len", "(", "[", "x", "for", "x", "in", "regs", "if", "x", "not", "in", "d", "]", ")", ":", "return", "False", "# If all registers are destroyed then they're not used", "for", "block", "in", "self", ".", "goes_to", ":", "if", "block", ".", "is_used", "(", "regs", ",", "0", ")", ":", "return", "True", "return", "False" ]

[ "Returns", "whether", "any", "of", "the", "goes_to", "block", "requires", "any", "of", "the", "given", "registers", "." ]

[ "def", "image_mapped", "(", "name", ")", ":", "try", ":", "out", "=", "check_output", "(", "[", "'rbd'", ",", "'showmapped'", "]", ")", "if", "six", ".", "PY3", ":", "out", "=", "out", ".", "decode", "(", "'UTF-8'", ")", "except", "CalledProcessError", ":", "return", "False", "return", "name", "in", "out" ]

[ "Determine", "whether", "a", "RADOS", "block", "device", "is", "mapped", "locally", "." ]

[ "def", "associate_model", "(", "model", ",", "field", ")", ":", "class_field", "=", "model", ".", "_meta", ".", "get_field", "(", "field", ")", "if", "hasattr", "(", "class_field", ",", "\"field\"", ")", ":", "return", "class_field", ".", "field", ".", "related", ".", "related_model", "else", ":", "return", "class_field", ".", "related_model" ]

[ "Return", "the", "model", "associate", "to", "the", "ForeignKey", "or", "ManyToMany", "relation" ]

[ "def", "detach_volume", "(", "self", ",", "volume_id", ",", "instance_id", "=", "None", ",", "device", "=", "None", ",", "force", "=", "False", ")", ":", "params", "=", "{", "'VolumeId'", ":", "volume_id", "}", "if", "instance_id", ":", "params", "[", "'InstanceId'", "]", "=", "instance_id", "if", "device", ":", "params", "[", "'Device'", "]", "=", "device", "if", "force", ":", "params", "[", "'Force'", "]", "=", "'true'", "return", "self", ".", "get_status", "(", "'DetachVolume'", ",", "params", ",", "verb", "=", "'POST'", ")" ]

[ "Detach", "an", "EBS", "volume", "from", "an", "EC2", "instance", "." ]

[ "def", "set_trunk_groups", "(", "self", ",", "intf", ",", "value", "=", "None", ",", "default", "=", "False", ",", "disable", "=", "False", ")", ":", "if", "default", ":", "cmd", "=", "'default switchport trunk group'", "return", "self", ".", "configure_interface", "(", "intf", ",", "cmd", ")", "if", "disable", ":", "cmd", "=", "'no switchport trunk group'", "return", "self", ".", "configure_interface", "(", "intf", ",", "cmd", ")", "current_value", "=", "self", ".", "get", "(", "intf", ")", "[", "'trunk_groups'", "]", "failure", "=", "False", "value", "=", "make_iterable", "(", "value", ")", "for", "name", "in", "set", "(", "value", ")", ".", "difference", "(", "current_value", ")", ":", "if", "not", "self", ".", "add_trunk_group", "(", "intf", ",", "name", ")", ":", "failure", "=", "True", "for", "name", "in", "set", "(", "current_value", ")", ".", "difference", "(", "value", ")", ":", "if", "not", "self", ".", "remove_trunk_group", "(", "intf", ",", "name", ")", ":", "failure", "=", "True", "return", "not", "failure" ]

[ "Configures", "the", "switchport", "trunk", "group", "value" ]

[ "def", "set_sound_mode", "(", "self", ",", "sound_mode", ")", ":", "if", "sound_mode", "==", "ALL_ZONE_STEREO", ":", "if", "self", ".", "_set_all_zone_stereo", "(", "True", ")", ":", "self", ".", "_sound_mode_raw", "=", "ALL_ZONE_STEREO", "return", "True", "else", ":", "return", "False", "if", "self", ".", "_sound_mode_raw", "==", "ALL_ZONE_STEREO", ":", "if", "not", "self", ".", "_set_all_zone_stereo", "(", "False", ")", ":", "return", "False", "# For selection of sound mode other names then at receiving sound modes", "# have to be used", "# Therefore source mapping is needed to get sound_mode", "# Create command URL and send command via HTTP GET", "command_url", "=", "self", ".", "_urls", ".", "command_sel_sound_mode", "+", "sound_mode", "# sent command", "try", ":", "if", "self", ".", "send_get_command", "(", "command_url", ")", ":", "self", ".", "_sound_mode_raw", "=", "self", ".", "_sound_mode_dict", "[", "sound_mode", "]", "[", "0", "]", "return", "True", "else", ":", "return", "False", "except", "requests", ".", "exceptions", ".", "RequestException", ":", "_LOGGER", ".", "error", "(", "\"Connection error: sound mode function %s not set.\"", ",", "sound_mode", ")", "return", "False" ]

[ "Set", "sound_mode", "of", "device", "." ]

[ "def", "_retrieve_indices", "(", "cols", ")", ":", "if", "isinstance", "(", "cols", ",", "int", ")", ":", "return", "[", "cols", "]", "elif", "isinstance", "(", "cols", ",", "slice", ")", ":", "start", "=", "cols", ".", "start", "if", "cols", ".", "start", "else", "0", "stop", "=", "cols", ".", "stop", "step", "=", "cols", ".", "step", "if", "cols", ".", "step", "else", "1", "return", "list", "(", "range", "(", "start", ",", "stop", ",", "step", ")", ")", "elif", "isinstance", "(", "cols", ",", "list", ")", "and", "cols", ":", "if", "isinstance", "(", "cols", "[", "0", "]", ",", "bool", ")", ":", "return", "np", ".", "flatnonzero", "(", "np", ".", "asarray", "(", "cols", ")", ")", "elif", "isinstance", "(", "cols", "[", "0", "]", ",", "int", ")", ":", "return", "cols", "else", ":", "raise", "TypeError", "(", "'No valid column specifier. Only a scalar, list or slice of all'", "'integers or a boolean mask are allowed.'", ")" ]

[ "Retrieve", "a", "list", "of", "indices", "corresponding", "to", "the", "provided", "column", "specification", "." ]

[ "def", "_set_bank_view", "(", "self", ",", "session", ")", ":", "if", "self", ".", "_bank_view", "==", "COMPARATIVE", ":", "try", ":", "session", ".", "use_comparative_bank_view", "(", ")", "except", "AttributeError", ":", "pass", "else", ":", "try", ":", "session", ".", "use_plenary_bank_view", "(", ")", "except", "AttributeError", ":", "pass" ]

[ "Sets", "the", "underlying", "bank", "view", "to", "match", "current", "view" ]

[ "def", "_get_resampler", "(", "self", ",", "obj", ",", "kind", "=", "None", ")", ":", "self", ".", "_set_grouper", "(", "obj", ")", "ax", "=", "self", ".", "ax", "if", "isinstance", "(", "ax", ",", "DatetimeIndex", ")", ":", "return", "DatetimeIndexResampler", "(", "obj", ",", "groupby", "=", "self", ",", "kind", "=", "kind", ",", "axis", "=", "self", ".", "axis", ")", "elif", "isinstance", "(", "ax", ",", "PeriodIndex", ")", "or", "kind", "==", "'period'", ":", "return", "PeriodIndexResampler", "(", "obj", ",", "groupby", "=", "self", ",", "kind", "=", "kind", ",", "axis", "=", "self", ".", "axis", ")", "elif", "isinstance", "(", "ax", ",", "TimedeltaIndex", ")", ":", "return", "TimedeltaIndexResampler", "(", "obj", ",", "groupby", "=", "self", ",", "axis", "=", "self", ".", "axis", ")", "raise", "TypeError", "(", "\"Only valid with DatetimeIndex, \"", "\"TimedeltaIndex or PeriodIndex, \"", "\"but got an instance of %r\"", "%", "type", "(", "ax", ")", ".", "__name__", ")" ]

[ "Return", "my", "resampler", "or", "raise", "if", "we", "have", "an", "invalid", "axis", "." ]

[ "def", "list_all_free_shippings", "(", "cls", ",", "*", "*", "kwargs", ")", ":", "kwargs", "[", "'_return_http_data_only'", "]", "=", "True", "if", "kwargs", ".", "get", "(", "'async'", ")", ":", "return", "cls", ".", "_list_all_free_shippings_with_http_info", "(", "*", "*", "kwargs", ")", "else", ":", "(", "data", ")", "=", "cls", ".", "_list_all_free_shippings_with_http_info", "(", "*", "*", "kwargs", ")", "return", "data" ]

[ "List", "FreeShippings" ]

[ "def", "save_session", "(", "self", ",", "*", "args", ",", "*", "*", "kwargs", ")", ":", "# do not send session cookie", "if", "g", ".", "get", "(", "'stateless_sessions'", ")", ":", "return", "# send cookie", "return", "super", "(", "BoilerSessionInterface", ",", "self", ")", ".", "save_session", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "Save", "session", "Skip", "setting", "session", "cookie", "if", "requested", "via", "g", ".", "stateless_sessions" ]

[ "def", "_Purge", "(", "self", ",", "event", ",", "by_tags", ")", ":", "## Keep data in reservoirs that has a step less than event.step", "_NotExpired", "=", "lambda", "x", ":", "x", ".", "step", "<", "event", ".", "step", "if", "by_tags", ":", "def", "_ExpiredPerTag", "(", "value", ")", ":", "return", "[", "getattr", "(", "self", ",", "x", ")", ".", "FilterItems", "(", "_NotExpired", ",", "value", ".", "tag", ")", "for", "x", "in", "self", ".", "accumulated_attrs", "]", "expired_per_tags", "=", "[", "_ExpiredPerTag", "(", "value", ")", "for", "value", "in", "event", ".", "summary", ".", "value", "]", "expired_per_type", "=", "[", "sum", "(", "x", ")", "for", "x", "in", "zip", "(", "*", "expired_per_tags", ")", "]", "else", ":", "expired_per_type", "=", "[", "getattr", "(", "self", ",", "x", ")", ".", "FilterItems", "(", "_NotExpired", ")", "for", "x", "in", "self", ".", "accumulated_attrs", "]", "if", "sum", "(", "expired_per_type", ")", ">", "0", ":", "purge_msg", "=", "_GetPurgeMessage", "(", "self", ".", "most_recent_step", ",", "self", ".", "most_recent_wall_time", ",", "event", ".", "step", ",", "event", ".", "wall_time", ",", "*", "expired_per_type", ")", "logger", ".", "warn", "(", "purge_msg", ")" ]

[ "Purge", "all", "events", "that", "have", "occurred", "after", "the", "given", "event", ".", "step", "." ]

[ "def", "pauseProducing", "(", "self", ")", ":", "if", "not", "self", ".", "_running", ":", "return", "# Exit the read loop and cancel the consumer on the server.", "self", ".", "_running", "=", "False", "for", "consumer", "in", "self", ".", "_consumers", ".", "values", "(", ")", ":", "yield", "consumer", ".", "channel", ".", "basic_cancel", "(", "consumer_tag", "=", "consumer", ".", "tag", ")", "_legacy_twisted_log", ".", "msg", "(", "\"Paused retrieval of messages for the server queue\"", ")" ]

[ "Pause", "the", "reception", "of", "messages", "by", "canceling", "all", "existing", "consumers", ".", "This", "does", "not", "disconnect", "from", "the", "server", "." ]

[ "def", "trajectory", "(", "self", ",", "horizon", ":", "int", ",", "initial_state", ":", "Optional", "[", "StateTensor", "]", "=", "None", ")", "->", "TrajectoryOutput", ":", "if", "initial_state", "is", "None", ":", "initial_state", "=", "self", ".", "_cell", ".", "initial_state", "(", ")", "with", "self", ".", "graph", ".", "as_default", "(", ")", ":", "self", ".", "inputs", "=", "self", ".", "timesteps", "(", "horizon", ")", "outputs", ",", "_", "=", "tf", ".", "nn", ".", "dynamic_rnn", "(", "self", ".", "_cell", ",", "self", ".", "inputs", ",", "initial_state", "=", "initial_state", ",", "dtype", "=", "tf", ".", "float32", ",", "scope", "=", "\"trajectory\"", ")", "states", ",", "actions", ",", "interms", ",", "rewards", "=", "outputs", "# fluent types", "state_dtype", "=", "map", "(", "rddl2tf", ".", "utils", ".", "range_type_to_dtype", ",", "self", ".", "_cell", ".", "_compiler", ".", "rddl", ".", "state_range_type", ")", "states", "=", "self", ".", "_output", "(", "states", ",", "state_dtype", ")", "interm_dtype", "=", "map", "(", "rddl2tf", ".", "utils", ".", "range_type_to_dtype", ",", "self", ".", "_cell", ".", "_compiler", ".", "rddl", ".", "interm_range_type", ")", "interms", "=", "self", ".", "_output", "(", "interms", ",", "interm_dtype", ")", "action_dtype", "=", "map", "(", "rddl2tf", ".", "utils", ".", "range_type_to_dtype", ",", "self", ".", "_cell", ".", "_compiler", ".", "rddl", ".", "action_range_type", ")", "actions", "=", "self", ".", "_output", "(", "actions", ",", "action_dtype", ")", "outputs", "=", "(", "initial_state", ",", "states", ",", "actions", ",", "interms", ",", "rewards", ")", "return", "outputs" ]

[ "Returns", "the", "ops", "for", "the", "trajectory", "generation", "with", "given", "horizon", "and", "initial_state", "." ]

[ "def", "get_key", "(", "s", ")", ":", "start", "=", "s", ".", "find", "(", "\"[\"", ")", "end", "=", "s", ".", "find", "(", "\"]\"", ")", "if", "start", "==", "-", "1", "or", "end", "==", "-", "1", ":", "return", "None", "if", "s", "[", "start", "+", "1", "]", "==", "\"'\"", ":", "start", "+=", "1", "if", "s", "[", "end", "-", "1", "]", "==", "\"'\"", ":", "end", "-=", "1", "return", "s", "[", "start", "+", "1", ":", "end", "]" ]

[ "Get", "data", "between", "[", "and", "]", "remove", "if", "exist" ]

[ "def", "_init_bins", "(", "self", ",", "binset", ")", ":", "if", "binset", "is", "None", ":", "if", "self", ".", "bandpass", ".", "waveset", "is", "not", "None", ":", "self", ".", "_binset", "=", "self", ".", "bandpass", ".", "waveset", "elif", "self", ".", "spectrum", ".", "waveset", "is", "not", "None", ":", "self", ".", "_binset", "=", "self", ".", "spectrum", ".", "waveset", "log", ".", "info", "(", "'Bandpass waveset is undefined; '", "'Using source spectrum waveset instead.'", ")", "else", ":", "raise", "exceptions", ".", "UndefinedBinset", "(", "'Both source spectrum and bandpass have undefined '", "'waveset; Provide binset manually.'", ")", "else", ":", "self", ".", "_binset", "=", "self", ".", "_validate_wavelengths", "(", "binset", ")", "# binset must be in ascending order for calcbinflux()", "# to work properly.", "if", "self", ".", "_binset", "[", "0", "]", ">", "self", ".", "_binset", "[", "-", "1", "]", ":", "self", ".", "_binset", "=", "self", ".", "_binset", "[", ":", ":", "-", "1", "]", "self", ".", "_bin_edges", "=", "binning", ".", "calculate_bin_edges", "(", "self", ".", "_binset", ")", "# Merge bin edges and centers in with the natural waveset", "spwave", "=", "utils", ".", "merge_wavelengths", "(", "self", ".", "_bin_edges", ".", "value", ",", "self", ".", "_binset", ".", "value", ")", "if", "self", ".", "waveset", "is", "not", "None", ":", "spwave", "=", "utils", ".", "merge_wavelengths", "(", "spwave", ",", "self", ".", "waveset", ".", "value", ")", "# Throw out invalid wavelengths after merging.", "spwave", "=", "spwave", "[", "spwave", ">", "0", "]", "# Compute indices associated to each endpoint.", "indices", "=", "np", ".", "searchsorted", "(", "spwave", ",", "self", ".", "_bin_edges", ".", "value", ")", "i_beg", "=", "indices", "[", ":", "-", "1", "]", "i_end", "=", "indices", "[", "1", ":", "]", "# Prepare integration variables.", "flux", "=", "self", "(", "spwave", ")", "avflux", "=", "(", "flux", ".", "value", "[", "1", ":", "]", "+", "flux", ".", "value", "[", ":", "-", "1", "]", ")", "*", "0.5", "deltaw", "=", "spwave", "[", "1", ":", "]", "-", "spwave", "[", ":", "-", "1", "]", "# Sum over each bin.", "binflux", ",", "intwave", "=", "binning", ".", "calcbinflux", "(", "self", ".", "_binset", ".", "size", ",", "i_beg", ",", "i_end", ",", "avflux", ",", "deltaw", ")", "self", ".", "_binflux", "=", "binflux", "*", "flux", ".", "unit" ]

[ "Calculated", "binned", "wavelength", "centers", "edges", "and", "flux", "." ]

[ "def", "cmd_rally_alt", "(", "self", ",", "args", ")", ":", "if", "(", "len", "(", "args", ")", "<", "2", ")", ":", "print", "(", "\"Usage: rally alt RALLYNUM newAlt <newBreakAlt>\"", ")", "return", "if", "not", "self", ".", "have_list", ":", "print", "(", "\"Please list rally points first\"", ")", "return", "idx", "=", "int", "(", "args", "[", "0", "]", ")", "if", "idx", "<=", "0", "or", "idx", ">", "self", ".", "rallyloader", ".", "rally_count", "(", ")", ":", "print", "(", "\"Invalid rally point number %u\"", "%", "idx", ")", "return", "new_alt", "=", "int", "(", "args", "[", "1", "]", ")", "new_break_alt", "=", "None", "if", "(", "len", "(", "args", ")", ">", "2", ")", ":", "new_break_alt", "=", "int", "(", "args", "[", "2", "]", ")", "self", ".", "rallyloader", ".", "set_alt", "(", "idx", ",", "new_alt", ",", "new_break_alt", ")", "self", ".", "send_rally_point", "(", "idx", "-", "1", ")", "self", ".", "fetch_rally_point", "(", "idx", "-", "1", ")", "self", ".", "rallyloader", ".", "reindex", "(", ")" ]

[ "handle", "rally", "alt", "change" ]

[ "def", "to_json", "(", "self", ")", ":", "data", "=", "dict", "(", ")", "for", "key", ",", "value", "in", "self", ".", "__dict__", ".", "items", "(", ")", ":", "if", "value", ":", "if", "hasattr", "(", "value", ",", "'to_dict'", ")", ":", "data", "[", "key", "]", "=", "value", ".", "to_dict", "(", ")", "elif", "isinstance", "(", "value", ",", "datetime", ")", ":", "data", "[", "key", "]", "=", "value", ".", "strftime", "(", "'%Y-%m-%d %H:%M:%S'", ")", "else", ":", "data", "[", "key", "]", "=", "value", "return", "json", ".", "dumps", "(", "data", ")" ]

[ "Returns", ":", "str", ":" ]

[ "def", "verify_login", "(", "request", ")", ":", "verifier", "=", "request", ".", "registry", "[", "'persona.verifier'", "]", "try", ":", "data", "=", "verifier", ".", "verify", "(", "request", ".", "POST", "[", "'assertion'", "]", ")", "except", "(", "ValueError", ",", "browserid", ".", "errors", ".", "TrustError", ")", "as", "e", ":", "logger", ".", "info", "(", "'Failed persona login: %s (%s)'", ",", "e", ",", "type", "(", "e", ")", ".", "__name__", ")", "raise", "HTTPBadRequest", "(", "'Invalid assertion'", ")", "return", "data", "[", "'email'", "]" ]

[ "Verifies", "the", "assertion", "and", "the", "csrf", "token", "in", "the", "given", "request", "." ]

[ "def", "elapsed", "(", "self", ")", ":", "if", "self", ".", "end", "is", "None", ":", "# if elapsed is called in the context manager scope", "return", "(", "self", "(", ")", "-", "self", ".", "start", ")", "*", "self", ".", "factor", "else", ":", "# if elapsed is called out of the context manager scope", "return", "(", "self", ".", "end", "-", "self", ".", "start", ")", "*", "self", ".", "factor" ]

[ "Return", "the", "current", "elapsed", "time", "since", "start", "If", "the", "elapsed", "property", "is", "called", "in", "the", "context", "manager", "scope", "the", "elapsed", "time", "bewteen", "start", "and", "property", "access", "is", "returned", ".", "However", "if", "it", "is", "accessed", "outside", "of", "the", "context", "manager", "scope", "it", "returns", "the", "elapsed", "time", "bewteen", "entering", "and", "exiting", "the", "scope", ".", "The", "elapsed", "property", "can", "thus", "be", "accessed", "at", "different", "points", "within", "the", "context", "manager", "scope", "to", "time", "different", "parts", "of", "the", "block", "." ]

[ "def", "registration_options", "(", "self", ")", ":", "registration_options", "=", "{", "}", "rs", "=", "self", ".", "registration_model", "(", ")", "for", "k", ",", "v", "in", "self", ".", "__dict__", ".", "items", "(", ")", ":", "if", "k", "not", "in", "DEFAULT_BASE_FIELDS", "+", "[", "'_state'", "]", ":", "try", ":", "getattr", "(", "rs", ",", "k", ")", "registration_options", ".", "update", "(", "{", "k", ":", "v", "}", ")", "except", "AttributeError", ":", "pass", "registration_identifier", "=", "registration_options", ".", "get", "(", "'registration_identifier'", ")", "if", "registration_identifier", ":", "registration_options", "[", "'registration_identifier'", "]", "=", "self", ".", "to_string", "(", "registration_identifier", ")", "return", "registration_options" ]

[ "Gathers", "values", "for", "common", "attributes", "between", "the", "registration", "model", "and", "this", "instance", "." ]

[ "def", "register_internal_data", "(", "cls", ")", ":", "with", "app", ".", "app_context", "(", ")", ":", "if", "getattr", "(", "cls", ",", "'endpoint'", ",", "None", ")", "is", "None", ":", "orig_class", "=", "cls", "cls", "=", "type", "(", "'Sandman'", "+", "cls", ".", "__name__", ",", "(", "cls", ",", "Model", ")", ",", "{", "}", ")", "cls", ".", "__from_class__", "=", "orig_class", "current_app", ".", "class_references", "[", "cls", ".", "__tablename__", "]", "=", "cls", "current_app", ".", "class_references", "[", "cls", ".", "__name__", "]", "=", "cls", "current_app", ".", "class_references", "[", "cls", ".", "endpoint", "(", ")", "]", "=", "cls", "if", "not", "getattr", "(", "cls", ",", "'__related_tables__'", ",", "None", ")", ":", "cls", ".", "__related_tables__", "=", "set", "(", ")" ]

[ "Register", "a", "new", "class", "*", "cls", "*", "with", "various", "internal", "data", "structures", "." ]

[ "def", "get_requirement_files", "(", "args", "=", "None", ")", ":", "if", "args", "and", "args", ".", "input_filename", ":", "return", "[", "args", ".", "input_filename", "]", "paths", "=", "[", "]", "for", "regex", "in", "settings", ".", "REQUIREMENTS_SOURCE_GLOBS", ":", "paths", ".", "extend", "(", "glob", ".", "glob", "(", "regex", ")", ")", "return", "paths" ]

[ "Get", "the", "best", "requirements", "file", "we", "can", "find" ]

[ "def", "storedata", "(", "self", ",", "fieldName", ",", "values", ",", "data_type", ",", "vName", ",", "vClass", ")", ":", "# See if the field is multi-valued.", "nrecs", "=", "len", "(", "values", ")", "if", "type", "(", "values", "[", "0", "]", ")", "in", "[", "list", ",", "tuple", "]", ":", "order", "=", "len", "(", "values", "[", "0", "]", ")", "# Replace input list with a flattened list.", "newValues", "=", "[", "]", "for", "el", "in", "values", ":", "for", "e", "in", "el", ":", "newValues", ".", "append", "(", "e", ")", "values", "=", "newValues", "else", ":", "order", "=", "1", "n_values", "=", "nrecs", "*", "order", "if", "data_type", "==", "HC", ".", "CHAR8", ":", "buf", "=", "_C", ".", "array_byte", "(", "n_values", ")", "# Allow values to be passed as a string.", "# Noop if a list is passed.", "values", "=", "list", "(", "values", ")", "for", "n", "in", "range", "(", "n_values", ")", ":", "values", "[", "n", "]", "=", "ord", "(", "values", "[", "n", "]", ")", "elif", "data_type", "in", "[", "HC", ".", "UCHAR8", ",", "HC", ".", "UINT8", "]", ":", "buf", "=", "_C", ".", "array_byte", "(", "n_values", ")", "elif", "data_type", "==", "HC", ".", "INT8", ":", "# SWIG refuses negative values here. We found that if we", "# pass them as byte values, it will work.", "buf", "=", "_C", ".", "array_int8", "(", "n_values", ")", "values", "=", "list", "(", "values", ")", "for", "n", "in", "range", "(", "n_values", ")", ":", "v", "=", "values", "[", "n", "]", "if", "v", ">=", "0", ":", "v", "&=", "0x7f", "else", ":", "v", "=", "abs", "(", "v", ")", "&", "0x7f", "if", "v", ":", "v", "=", "256", "-", "v", "else", ":", "v", "=", "128", "# -128 in 2s complement", "values", "[", "n", "]", "=", "v", "elif", "data_type", "==", "HC", ".", "INT16", ":", "buf", "=", "_C", ".", "array_int16", "(", "n_values", ")", "elif", "data_type", "==", "HC", ".", "UINT16", ":", "buf", "=", "_C", ".", "array_uint16", "(", "n_values", ")", "elif", "data_type", "==", "HC", ".", "INT32", ":", "buf", "=", "_C", ".", "array_int32", "(", "n_values", ")", "elif", "data_type", "==", "HC", ".", "UINT32", ":", "buf", "=", "_C", ".", "array_uint32", "(", "n_values", ")", "elif", "data_type", "==", "HC", ".", "FLOAT32", ":", "buf", "=", "_C", ".", "array_float32", "(", "n_values", ")", "elif", "data_type", "==", "HC", ".", "FLOAT64", ":", "buf", "=", "_C", ".", "array_float64", "(", "n_values", ")", "else", ":", "raise", "HDF4Error", "(", "\"storedata: illegal or unimplemented data_type\"", ")", "for", "n", "in", "range", "(", "n_values", ")", ":", "buf", "[", "n", "]", "=", "values", "[", "n", "]", "if", "order", "==", "1", ":", "vd", "=", "_C", ".", "VHstoredata", "(", "self", ".", "_hdf_inst", ".", "_id", ",", "fieldName", ",", "buf", ",", "nrecs", ",", "data_type", ",", "vName", ",", "vClass", ")", "else", ":", "vd", "=", "_C", ".", "VHstoredatam", "(", "self", ".", "_hdf_inst", ".", "_id", ",", "fieldName", ",", "buf", ",", "nrecs", ",", "data_type", ",", "vName", ",", "vClass", ",", "order", ")", "_checkErr", "(", "'storedata'", ",", "vd", ",", "'cannot create vdata'", ")", "return", "vd" ]

[ "Create", "and", "initialize", "a", "single", "field", "vdata", "returning", "the", "vdata", "reference", "number", "." ]

[ "def", "create_tag", "(", "self", ",", "name", ",", "description", "=", "None", ",", "servers", "=", "[", "]", ")", ":", "servers", "=", "[", "str", "(", "server", ")", "for", "server", "in", "servers", "]", "body", "=", "{", "'tag'", ":", "Tag", "(", "name", ",", "description", ",", "servers", ")", ".", "to_dict", "(", ")", "}", "res", "=", "self", ".", "request", "(", "'POST'", ",", "'/tag'", ",", "body", ")", "return", "Tag", "(", "cloud_manager", "=", "self", ",", "*", "*", "res", "[", "'tag'", "]", ")" ]

[ "Create", "a", "new", "Tag", ".", "Only", "name", "is", "mandatory", "." ]

[ "def", "list_commit", "(", "self", ",", "repo_name", ",", "to_commit", "=", "None", ",", "from_commit", "=", "None", ",", "number", "=", "0", ")", ":", "req", "=", "proto", ".", "ListCommitRequest", "(", "repo", "=", "proto", ".", "Repo", "(", "name", "=", "repo_name", ")", ",", "number", "=", "number", ")", "if", "to_commit", "is", "not", "None", ":", "req", ".", "to", ".", "CopyFrom", "(", "commit_from", "(", "to_commit", ")", ")", "if", "from_commit", "is", "not", "None", ":", "getattr", "(", "req", ",", "'from'", ")", ".", "CopyFrom", "(", "commit_from", "(", "from_commit", ")", ")", "res", "=", "self", ".", "stub", ".", "ListCommit", "(", "req", ",", "metadata", "=", "self", ".", "metadata", ")", "if", "hasattr", "(", "res", ",", "'commit_info'", ")", ":", "return", "res", ".", "commit_info", "return", "[", "]" ]

[ "Gets", "a", "list", "of", "CommitInfo", "objects", "." ]

[ "def", "get_private_key", "(", "key_path", ",", "password_path", "=", "None", ")", ":", "assert", "key_path", ",", "key_path", "if", "not", "os", ".", "path", ".", "exists", "(", "key_path", ")", ":", "log", ".", "fatal", "(", "'%s: no such file'", ",", "key_path", ")", "return", "None", "if", "not", "check_permission_safety", "(", "key_path", ")", ":", "log", ".", "fatal", "(", "'Private key file %s must be readable only by its owner.'", ",", "key_path", ")", "return", "None", "if", "password_path", "and", "not", "check_permission_safety", "(", "password_path", ")", ":", "log", ".", "fatal", "(", "'Password file %s must be readable only by its owner.'", ",", "password_path", ")", "return", "None", "with", "open", "(", "key_path", ")", "as", "keyfile", ":", "private_key", "=", "keyfile", ".", "readline", "(", ")", ".", "strip", "(", ")", "if", "is_hex", "(", "private_key", ")", "and", "len", "(", "decode_hex", "(", "private_key", ")", ")", "==", "32", ":", "log", ".", "warning", "(", "'Private key in raw format. Consider switching to JSON-encoded'", ")", "else", ":", "keyfile", ".", "seek", "(", "0", ")", "try", ":", "json_data", "=", "json", ".", "load", "(", "keyfile", ")", "if", "password_path", ":", "with", "open", "(", "password_path", ")", "as", "password_file", ":", "password", "=", "password_file", ".", "readline", "(", ")", ".", "strip", "(", ")", "else", ":", "password", "=", "getpass", ".", "getpass", "(", "'Enter the private key password: '", ")", "if", "json_data", "[", "'crypto'", "]", "[", "'kdf'", "]", "==", "'pbkdf2'", ":", "password", "=", "password", ".", "encode", "(", ")", "# type: ignore", "private_key", "=", "encode_hex", "(", "decode_keyfile_json", "(", "json_data", ",", "password", ")", ")", "except", "ValueError", ":", "log", ".", "fatal", "(", "'Invalid private key format or password!'", ")", "return", "None", "return", "private_key" ]

[ "Open", "a", "JSON", "-", "encoded", "private", "key", "and", "return", "it" ]

[ "def", "makeService", "(", "opt", ")", ":", "restarter", ",", "path", "=", "beatcheck", ".", "parseConfig", "(", "opt", ")", "pool", "=", "client", ".", "HTTPConnectionPool", "(", "reactor", ")", "agent", "=", "client", ".", "Agent", "(", "reactor", "=", "reactor", ",", "pool", "=", "pool", ")", "settings", "=", "Settings", "(", "reactor", "=", "reactor", ",", "agent", "=", "agent", ")", "states", "=", "{", "}", "checker", "=", "functools", ".", "partial", "(", "check", ",", "settings", ",", "states", ",", "path", ")", "httpcheck", "=", "tainternet", ".", "TimerService", "(", "opt", "[", "'freq'", "]", ",", "run", ",", "restarter", ",", "checker", ")", "httpcheck", ".", "setName", "(", "'httpcheck'", ")", "return", "heart", ".", "wrapHeart", "(", "httpcheck", ")" ]

[ "Make", "a", "service" ]

[ "def", "ensure_sink", "(", "self", ")", ":", "topic_info", "=", "self", ".", "pubsub", ".", "ensure_topic", "(", ")", "scope", ",", "sink_path", ",", "sink_info", "=", "self", ".", "get_sink", "(", "topic_info", ")", "client", "=", "self", ".", "session", ".", "client", "(", "'logging'", ",", "'v2'", ",", "'%s.sinks'", "%", "scope", ")", "try", ":", "sink", "=", "client", ".", "execute_command", "(", "'get'", ",", "{", "'sinkName'", ":", "sink_path", "}", ")", "except", "HttpError", "as", "e", ":", "if", "e", ".", "resp", ".", "status", "!=", "404", ":", "raise", "sink", "=", "client", ".", "execute_command", "(", "'create'", ",", "sink_info", ")", "else", ":", "delta", "=", "delta_resource", "(", "sink", ",", "sink_info", "[", "'body'", "]", ")", "if", "delta", ":", "sink_info", "[", "'updateMask'", "]", "=", "','", ".", "join", "(", "delta", ")", "sink_info", "[", "'sinkName'", "]", "=", "sink_path", "sink_info", ".", "pop", "(", "'parent'", ")", "sink", "=", "client", ".", "execute_command", "(", "'update'", ",", "sink_info", ")", "else", ":", "return", "sink_path", "self", ".", "pubsub", ".", "ensure_iam", "(", "publisher", "=", "sink", "[", "'writerIdentity'", "]", ")", "return", "sink_path" ]

[ "Ensure", "the", "log", "sink", "and", "its", "pub", "sub", "topic", "exist", "." ]

[ "def", "deserialize_email_messages", "(", "messages", ":", "List", "[", "str", "]", ")", ":", "return", "[", "pickle", ".", "loads", "(", "zlib", ".", "decompress", "(", "base64", ".", "b64decode", "(", "m", ")", ")", ")", "for", "m", "in", "messages", "]" ]

[ "Deserialize", "EmailMessages", "passed", "as", "task", "argument", "." ]

[ "def", "xml2object", "(", "xml", ",", "verbose", "=", "False", ")", ":", "# FIXME - can we allow xml to be string?", "# This would depend on minidom's parse function", "# Input tests", "if", "isinstance", "(", "xml", ",", "basestring", ")", ":", "fid", "=", "open", "(", "xml", ")", "else", ":", "fid", "=", "xml", "try", ":", "dom", "=", "parse", "(", "fid", ")", "except", "Exception", "as", "e", ":", "# Throw filename into dom exception", "msg", "=", "'XML file \"%s\" could not be parsed.\\n'", "%", "fid", ".", "name", "msg", "+=", "'Error message from parser: \"%s\"'", "%", "str", "(", "e", ")", "raise", "Exception", ",", "msg", "try", ":", "xml_object", "=", "dom2object", "(", "dom", ")", "except", "Exception", "as", "e", ":", "msg", "=", "'Could not convert %s into XML object.\\n'", "%", "fid", ".", "name", "msg", "+=", "str", "(", "e", ")", "raise", "Exception", ",", "msg", "return", "xml_object" ]

[ "Generate", "XML", "object", "model", "from", "XML", "file", "or", "XML", "text" ]

[ "def", "_bsd_stp", "(", "br", ",", "state", ",", "iface", ")", ":", "kernel", "=", "__grains__", "[", "'kernel'", "]", "if", "kernel", "==", "'NetBSD'", ":", "cmd", "=", "_tool_path", "(", "'brconfig'", ")", "else", ":", "cmd", "=", "_tool_path", "(", "'ifconfig'", ")", "if", "not", "br", "or", "not", "iface", ":", "return", "False", "return", "__salt__", "[", "'cmd.run'", "]", "(", "'{0} {1} {2} {3}'", ".", "format", "(", "cmd", ",", "br", ",", "state", ",", "iface", ")", ",", "python_shell", "=", "False", ")" ]

[ "Internal", "sets", "STP", "state", ".", "On", "BSD", "-", "like", "it", "is", "required", "to", "specify", "the", "STP", "physical", "interface" ]

[ "def", "_resolve_value", "(", "self", ",", "value", ",", "environment", "=", "None", ")", ":", "# here we care about Undefined values", "if", "value", "==", "values", ".", "Undefined", ":", "if", "isinstance", "(", "self", ".", "_missing", ",", "type", ")", "and", "issubclass", "(", "self", ".", "_missing", ",", "Missing", ")", ":", "# instantiate the missing thing", "missing", "=", "self", ".", "_missing", "(", "self", ",", "environment", ")", "# invoke missing callback", "# the default is to raise a MissingValue() exception", "value", "=", "missing", "(", "value", ")", "elif", "hasattr", "(", "self", ".", "_missing", ",", "\"__call__\"", ")", ":", "value", "=", "self", ".", "_missing", "(", ")", "else", ":", "# we just assign any value", "value", "=", "self", ".", "_missing", "return", "value" ]

[ "Resolve", "the", "value", "." ]

[ "def", "get_controller", "(", "self", ")", ":", "command", "=", "ovs_vsctl", ".", "VSCtlCommand", "(", "'get-controller'", ",", "[", "self", ".", "br_name", "]", ")", "self", ".", "run_command", "(", "[", "command", "]", ")", "result", "=", "command", ".", "result", "return", "result", "[", "0", "]", "if", "len", "(", "result", ")", "==", "1", "else", "result" ]

[ "Gets", "the", "configured", "OpenFlow", "controller", "address", "." ]

[ "def", "wait_until_text_is_not_empty", "(", "self", ",", "locator", ",", "timeout", "=", "None", ")", ":", "timeout", "=", "timeout", "if", "timeout", "is", "not", "None", "else", "self", ".", "timeout", "self", ".", "wait_for", "(", "locator", ")", "# first check that element exists", "def", "wait", "(", ")", ":", "'''\n Wait function passed to executor\n '''", "WebDriverWait", "(", "self", ".", "driver", ",", "timeout", ")", ".", "until", "(", "lambda", "d", ":", "len", "(", "self", ".", "find", "(", "locator", ")", ".", "text", "(", ")", ")", ">", "0", ")", "return", "self", ".", "find", "(", "locator", ")", "return", "self", ".", "execute_and_handle_webdriver_exceptions", "(", "wait", ",", "timeout", ",", "locator", ",", "'Timeout waiting for element to contain some text'", ")" ]

[ "Waits", "for", "an", "element", "s", "text", "to", "not", "be", "empty" ]

[ "def", "quickinfo", "(", "self", ")", ":", "return", "\"dir: \"", "+", "str", "(", "self", ".", "config", "[", "\"dir\"", "]", ")", "+", "\", files: \"", "+", "str", "(", "self", ".", "config", "[", "\"list_files\"", "]", ")", "+", "\", dirs: \"", "+", "str", "(", "self", ".", "resolve_option", "(", "\"list_dirs\"", ")", ")", "+", "\", recursive: \"", "+", "str", "(", "self", ".", "config", "[", "\"recursive\"", "]", ")" ]

[ "Returns", "a", "short", "string", "describing", "some", "of", "the", "options", "of", "the", "actor", "." ]

[ "def", "get_contribution", "(", "self", ",", "url", ")", ":", "result", "=", "self", ".", "api_request", "(", "url", ")", "# add the contrib id into the metadata", "result", "[", "'id'", "]", "=", "os", ".", "path", ".", "split", "(", "result", "[", "'url'", "]", ")", "[", "1", "]", "return", "result" ]

[ "Get", "the", "details", "of", "a", "particular", "contribution", "given", "it", "s", "url" ]

[ "def", "digest_prelude", "(", "self", ",", "rule", ")", ":", "name", "=", "[", "]", "for", "token", "in", "rule", ".", "prelude", ":", "if", "token", ".", "type", "==", "'ident'", ":", "name", ".", "append", "(", "token", ".", "value", ")", "return", "\"__\"", ".", "join", "(", "name", ")" ]

[ "Walk", "on", "rule", "prelude", "(", "aka", "CSS", "selector", ")", "tokens", "to", "return", "a", "string", "of", "the", "value", "name", "(", "from", "css", "selector", ")", "." ]

[ "def", "__request_message_descriptor", "(", "self", ",", "request_kind", ",", "message_type", ",", "method_id", ",", "path", ")", ":", "if", "isinstance", "(", "message_type", ",", "resource_container", ".", "ResourceContainer", ")", ":", "base_message_type", "=", "message_type", ".", "body_message_class", "(", ")", "if", "(", "request_kind", "==", "self", ".", "__NO_BODY", "and", "base_message_type", "!=", "message_types", ".", "VoidMessage", "(", ")", ")", ":", "msg", "=", "(", "'Method %s specifies a body message in its ResourceContainer, but '", "'is a HTTP method type that cannot accept a body.'", ")", "%", "method_id", "raise", "api_exceptions", ".", "ApiConfigurationError", "(", "msg", ")", "else", ":", "base_message_type", "=", "message_type", "if", "(", "request_kind", "!=", "self", ".", "__NO_BODY", "and", "base_message_type", "!=", "message_types", ".", "VoidMessage", "(", ")", ")", ":", "self", ".", "__request_schema", "[", "method_id", "]", "=", "self", ".", "__parser", ".", "add_message", "(", "base_message_type", ".", "__class__", ")", "params", "=", "self", ".", "__params_descriptor", "(", "message_type", ",", "request_kind", ",", "path", ",", "method_id", ")", "return", "params" ]

[ "Describes", "the", "parameters", "and", "body", "of", "the", "request", "." ]

[ "def", "upload_progress", "(", "request", ")", ":", "if", "'X-Progress-ID'", "in", "request", ".", "GET", ":", "progress_id", "=", "request", ".", "GET", "[", "'X-Progress-ID'", "]", "elif", "'X-Progress-ID'", "in", "request", ".", "META", ":", "progress_id", "=", "request", ".", "META", "[", "'X-Progress-ID'", "]", "if", "'logfilename'", "in", "request", ".", "GET", ":", "logfilename", "=", "request", ".", "GET", "[", "'logfilename'", "]", "elif", "'logfilename'", "in", "request", ".", "META", ":", "logfilename", "=", "request", ".", "META", "[", "'logfilename'", "]", "cache_key", "=", "\"%s_%s\"", "%", "(", "request", ".", "META", "[", "'REMOTE_ADDR'", "]", ",", "progress_id", ")", "data", "=", "cache", ".", "get", "(", "cache_key", ")", "if", "not", "data", ":", "data", "=", "cache", ".", "get", "(", "logfilename", ".", "replace", "(", "' '", ",", "'_'", ")", ")", "return", "HttpResponse", "(", "json", ".", "dumps", "(", "data", ")", ")" ]

[ "AJAX", "view", "adapted", "from", "django", "-", "progressbarupload" ]

[ "def", "deploy_lambda_alb", "(", "self", ",", "lambda_arn", ",", "lambda_name", ",", "alb_vpc_config", ",", "timeout", ")", ":", "if", "not", "alb_vpc_config", ":", "raise", "EnvironmentError", "(", "'When creating an ALB, alb_vpc_config must be filled out in zappa_settings.'", ")", "if", "'SubnetIds'", "not", "in", "alb_vpc_config", ":", "raise", "EnvironmentError", "(", "'When creating an ALB, you must supply two subnets in different availability zones.'", ")", "if", "'SecurityGroupIds'", "not", "in", "alb_vpc_config", ":", "alb_vpc_config", "[", "\"SecurityGroupIds\"", "]", "=", "[", "]", "if", "not", "alb_vpc_config", ".", "get", "(", "'CertificateArn'", ")", ":", "raise", "EnvironmentError", "(", "'When creating an ALB, you must supply a CertificateArn for the HTTPS listener.'", ")", "print", "(", "\"Deploying ALB infrastructure...\"", ")", "# Create load balancer", "# https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/elbv2.html#ElasticLoadBalancingv2.Client.create_load_balancer", "kwargs", "=", "dict", "(", "Name", "=", "lambda_name", ",", "Subnets", "=", "alb_vpc_config", "[", "\"SubnetIds\"", "]", ",", "SecurityGroups", "=", "alb_vpc_config", "[", "\"SecurityGroupIds\"", "]", ",", "# TODO: Scheme can also be \"internal\" we need to add a new option for this.", "Scheme", "=", "\"internet-facing\"", ",", "# TODO: Tags might be a useful means of stock-keeping zappa-generated assets.", "#Tags=[],", "Type", "=", "\"application\"", ",", "# TODO: can be ipv4 or dualstack (for ipv4 and ipv6) ipv4 is required for internal Scheme.", "IpAddressType", "=", "\"ipv4\"", ")", "response", "=", "self", ".", "elbv2_client", ".", "create_load_balancer", "(", "*", "*", "kwargs", ")", "if", "not", "(", "response", "[", "\"LoadBalancers\"", "]", ")", "or", "len", "(", "response", "[", "\"LoadBalancers\"", "]", ")", "!=", "1", ":", "raise", "EnvironmentError", "(", "\"Failure to create application load balancer. Response was in unexpected format. Response was: {}\"", ".", "format", "(", "repr", "(", "response", ")", ")", ")", "if", "response", "[", "\"LoadBalancers\"", "]", "[", "0", "]", "[", "'State'", "]", "[", "'Code'", "]", "==", "'failed'", ":", "raise", "EnvironmentError", "(", "\"Failure to create application load balancer. Response reported a failed state: {}\"", ".", "format", "(", "response", "[", "\"LoadBalancers\"", "]", "[", "0", "]", "[", "'State'", "]", "[", "'Reason'", "]", ")", ")", "load_balancer_arn", "=", "response", "[", "\"LoadBalancers\"", "]", "[", "0", "]", "[", "\"LoadBalancerArn\"", "]", "load_balancer_dns", "=", "response", "[", "\"LoadBalancers\"", "]", "[", "0", "]", "[", "\"DNSName\"", "]", "load_balancer_vpc", "=", "response", "[", "\"LoadBalancers\"", "]", "[", "0", "]", "[", "\"VpcId\"", "]", "waiter", "=", "self", ".", "elbv2_client", ".", "get_waiter", "(", "'load_balancer_available'", ")", "# Match the lambda timeout on the load balancer.", "self", ".", "elbv2_client", ".", "modify_load_balancer_attributes", "(", "LoadBalancerArn", "=", "load_balancer_arn", ",", "Attributes", "=", "[", "{", "'Key'", ":", "'idle_timeout.timeout_seconds'", ",", "'Value'", ":", "str", "(", "timeout", ")", "}", "]", ")", "# Create/associate target group.", "# https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/elbv2.html#ElasticLoadBalancingv2.Client.create_target_group", "kwargs", "=", "dict", "(", "Name", "=", "lambda_name", ",", "TargetType", "=", "\"lambda\"", ",", "# TODO: Add options for health checks", ")", "response", "=", "self", ".", "elbv2_client", ".", "create_target_group", "(", "*", "*", "kwargs", ")", "if", "not", "(", "response", "[", "\"TargetGroups\"", "]", ")", "or", "len", "(", "response", "[", "\"TargetGroups\"", "]", ")", "!=", "1", ":", "raise", "EnvironmentError", "(", "\"Failure to create application load balancer target group. Response was in unexpected format. Response was: {}\"", ".", "format", "(", "repr", "(", "response", ")", ")", ")", "target_group_arn", "=", "response", "[", "\"TargetGroups\"", "]", "[", "0", "]", "[", "\"TargetGroupArn\"", "]", "# Enable multi-value headers by default.", "response", "=", "self", ".", "elbv2_client", ".", "modify_target_group_attributes", "(", "TargetGroupArn", "=", "target_group_arn", ",", "Attributes", "=", "[", "{", "'Key'", ":", "'lambda.multi_value_headers.enabled'", ",", "'Value'", ":", "'true'", "}", ",", "]", ")", "# Allow execute permissions from target group to lambda.", "# https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/lambda.html#Lambda.Client.add_permission", "kwargs", "=", "dict", "(", "Action", "=", "\"lambda:InvokeFunction\"", ",", "FunctionName", "=", "\"{}:{}\"", ".", "format", "(", "lambda_arn", ",", "ALB_LAMBDA_ALIAS", ")", ",", "Principal", "=", "\"elasticloadbalancing.amazonaws.com\"", ",", "SourceArn", "=", "target_group_arn", ",", "StatementId", "=", "lambda_name", ")", "response", "=", "self", ".", "lambda_client", ".", "add_permission", "(", "*", "*", "kwargs", ")", "# Register target group to lambda association.", "# https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/elbv2.html#ElasticLoadBalancingv2.Client.register_targets", "kwargs", "=", "dict", "(", "TargetGroupArn", "=", "target_group_arn", ",", "Targets", "=", "[", "{", "\"Id\"", ":", "\"{}:{}\"", ".", "format", "(", "lambda_arn", ",", "ALB_LAMBDA_ALIAS", ")", "}", "]", ")", "response", "=", "self", ".", "elbv2_client", ".", "register_targets", "(", "*", "*", "kwargs", ")", "# Bind listener to load balancer with default rule to target group.", "# https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/elbv2.html#ElasticLoadBalancingv2.Client.create_listener", "kwargs", "=", "dict", "(", "# TODO: Listeners support custom ssl certificates (Certificates). For now we leave this default.", "Certificates", "=", "[", "{", "\"CertificateArn\"", ":", "alb_vpc_config", "[", "'CertificateArn'", "]", "}", "]", ",", "DefaultActions", "=", "[", "{", "\"Type\"", ":", "\"forward\"", ",", "\"TargetGroupArn\"", ":", "target_group_arn", ",", "}", "]", ",", "LoadBalancerArn", "=", "load_balancer_arn", ",", "Protocol", "=", "\"HTTPS\"", ",", "# TODO: Add option for custom ports", "Port", "=", "443", ",", "# TODO: Listeners support custom ssl security policy (SslPolicy). For now we leave this default.", ")", "response", "=", "self", ".", "elbv2_client", ".", "create_listener", "(", "*", "*", "kwargs", ")", "print", "(", "\"ALB created with DNS: {}\"", ".", "format", "(", "load_balancer_dns", ")", ")", "print", "(", "\"Note it may take several minutes for load balancer to become available.\"", ")" ]

[ "The", "zappa", "deploy", "functionality", "for", "ALB", "infrastructure", "." ]

[ "def", "compile_pattern_list", "(", "self", ",", "patterns", ")", ":", "if", "patterns", "is", "None", ":", "return", "[", "]", "if", "not", "isinstance", "(", "patterns", ",", "list", ")", ":", "patterns", "=", "[", "patterns", "]", "# Allow dot to match \\n", "compile_flags", "=", "re", ".", "DOTALL", "if", "self", ".", "ignorecase", ":", "compile_flags", "=", "compile_flags", "|", "re", ".", "IGNORECASE", "compiled_pattern_list", "=", "[", "]", "for", "idx", ",", "p", "in", "enumerate", "(", "patterns", ")", ":", "if", "isinstance", "(", "p", ",", "self", ".", "allowed_string_types", ")", ":", "p", "=", "self", ".", "_coerce_expect_string", "(", "p", ")", "compiled_pattern_list", ".", "append", "(", "re", ".", "compile", "(", "p", ",", "compile_flags", ")", ")", "elif", "p", "is", "EOF", ":", "compiled_pattern_list", ".", "append", "(", "EOF", ")", "elif", "p", "is", "TIMEOUT", ":", "compiled_pattern_list", ".", "append", "(", "TIMEOUT", ")", "elif", "isinstance", "(", "p", ",", "type", "(", "re", ".", "compile", "(", "''", ")", ")", ")", ":", "compiled_pattern_list", ".", "append", "(", "p", ")", "else", ":", "self", ".", "_pattern_type_err", "(", "p", ")", "return", "compiled_pattern_list" ]

[ "This", "compiles", "a", "pattern", "-", "string", "or", "a", "list", "of", "pattern", "-", "strings", ".", "Patterns", "must", "be", "a", "StringType", "EOF", "TIMEOUT", "SRE_Pattern", "or", "a", "list", "of", "those", ".", "Patterns", "may", "also", "be", "None", "which", "results", "in", "an", "empty", "list", "(", "you", "might", "do", "this", "if", "waiting", "for", "an", "EOF", "or", "TIMEOUT", "condition", "without", "expecting", "any", "pattern", ")", "." ]

[ "def", "push_script", "(", "self", ",", "scriptable", ",", "script", ",", "callback", "=", "None", ")", ":", "if", "script", "in", "self", ".", "threads", ":", "self", ".", "threads", "[", "script", "]", ".", "finish", "(", ")", "thread", "=", "Thread", "(", "self", ".", "run_script", "(", "scriptable", ",", "script", ")", ",", "scriptable", ",", "callback", ")", "self", ".", "new_threads", "[", "script", "]", "=", "thread", "return", "thread" ]

[ "Run", "the", "script", "and", "add", "it", "to", "the", "list", "of", "threads", "." ]

[ "def", "skip", "(", "self", ",", "content", ")", ":", "if", "self", ".", "optional", "(", "content", ")", ":", "v", "=", "content", ".", "value", "if", "v", "is", "None", ":", "return", "True", "if", "isinstance", "(", "v", ",", "(", "list", ",", "tuple", ")", ")", "and", "not", "v", ":", "return", "True", "return", "False" ]

[ "Get", "whether", "to", "skip", "this", "I", "{", "content", "}", "." ]

[ "def", "fail", "(", "self", ",", "group", ",", "message", ")", ":", "logger", ".", "warn", "(", "'Failing %s (%s): %s'", ",", "self", ".", "jid", ",", "group", ",", "message", ")", "return", "self", ".", "client", "(", "'fail'", ",", "self", ".", "jid", ",", "self", ".", "client", ".", "worker_name", ",", "group", ",", "message", ",", "json", ".", "dumps", "(", "self", ".", "data", ")", ")", "or", "False" ]

[ "Mark", "the", "particular", "job", "as", "failed", "with", "the", "provided", "type", "and", "a", "more", "specific", "message", ".", "By", "type", "we", "mean", "some", "phrase", "that", "might", "be", "one", "of", "several", "categorical", "modes", "of", "failure", ".", "The", "message", "is", "something", "more", "job", "-", "specific", "like", "perhaps", "a", "traceback", "." ]

[ "def", "class_in_progress", "(", "stack", "=", "None", ")", ":", "if", "stack", "is", "None", ":", "stack", "=", "inspect", ".", "stack", "(", ")", "for", "frame", "in", "stack", ":", "statement_list", "=", "frame", "[", "4", "]", "if", "statement_list", "is", "None", ":", "continue", "if", "statement_list", "[", "0", "]", ".", "strip", "(", ")", ".", "startswith", "(", "'class '", ")", ":", "return", "True", "return", "False" ]

[ "True", "if", "currently", "inside", "a", "class", "definition", "else", "False", "." ]

[ "def", "build_training_request", "(", "csv_file", "=", "ev", "(", "\"CSV_FILE\"", ",", "\"/tmp/cleaned_attack_scans.csv\"", ")", ",", "meta_file", "=", "ev", "(", "\"CSV_META_FILE\"", ",", "\"/tmp/cleaned_metadata.json\"", ")", ",", "predict_feature", "=", "ev", "(", "\"PREDICT_FEATURE\"", ",", "\"label_value\"", ")", ",", "ignore_features", "=", "[", "\"label_name\"", ",", "\"ip_src\"", ",", "# need to make this an int", "\"ip_dst\"", ",", "# need to make this an int", "\"eth_src\"", ",", "# need to make this an int", "\"eth_dst\"", "# need to make this an int", "]", ",", "seed", "=", "None", ",", "test_size", "=", "float", "(", "ev", "(", "\"TEST_SIZE\"", ",", "\"0.20\"", ")", ")", ",", "preproc_rules", "=", "None", ")", ":", "last_step", "=", "\"not started\"", "res", "=", "{", "\"status\"", ":", "INVALID", ",", "\"err\"", ":", "\"\"", ",", "\"csv_file\"", ":", "csv_file", ",", "\"meta_file\"", ":", "meta_file", ",", "\"meta_data\"", ":", "None", ",", "\"seed\"", ":", "None", ",", "\"test_size\"", ":", "test_size", ",", "\"predict_feature\"", ":", "predict_feature", ",", "\"features_to_process\"", ":", "[", "]", ",", "\"ignore_features\"", ":", "ignore_features", ",", "\"X_train\"", ":", "None", ",", "\"X_test\"", ":", "None", ",", "\"Y_train\"", ":", "None", ",", "\"Y_test\"", ":", "None", "}", "try", ":", "last_step", "=", "(", "\"building seed={}\"", ")", ".", "format", "(", "seed", ")", "log", ".", "debug", "(", "last_step", ")", "use_seed", "=", "seed", "if", "not", "use_seed", ":", "use_seed", "=", "9", "res", "[", "\"seed\"", "]", "=", "np", ".", "random", ".", "seed", "(", "use_seed", ")", "last_step", "=", "(", "\"Loading csv={}\"", ")", ".", "format", "(", "csv_file", ")", "log", ".", "info", "(", "last_step", ")", "if", "not", "os", ".", "path", ".", "exists", "(", "csv_file", ")", ":", "res", "[", "\"status\"", "]", "=", "ERROR", "res", "[", "\"err\"", "]", "=", "(", "\"Unable to find csv_file={}\"", ")", ".", "format", "(", "csv_file", ")", "log", ".", "error", "(", "res", "[", "\"err\"", "]", ")", "return", "res", "# end of checking for a valid csv file on disk", "if", "not", "os", ".", "path", ".", "exists", "(", "meta_file", ")", ":", "res", "[", "\"status\"", "]", "=", "ERROR", "res", "[", "\"err\"", "]", "=", "(", "\"Unable to find meta_file={}\"", ")", ".", "format", "(", "meta_file", ")", "log", ".", "error", "(", "res", "[", "\"err\"", "]", ")", "return", "res", "# end of checking for a valid metadata file on disk", "# load csv file into pandas dataframe", "df", "=", "pd", ".", "read_csv", "(", "csv_file", ")", "features_to_process", "=", "[", "]", "meta_data", "=", "{", "}", "try", ":", "last_step", "=", "(", "\"opening metadata={}\"", ")", ".", "format", "(", "meta_file", ")", "log", ".", "debug", "(", "last_step", ")", "meta_data", "=", "json", ".", "loads", "(", "open", "(", "meta_file", ",", "\"r\"", ")", ".", "read", "(", ")", ")", "res", "[", "\"meta_data\"", "]", "=", "meta_data", "if", "\"post_proc_rules\"", "in", "meta_data", ":", "if", "\"drop_columns\"", "in", "meta_data", "[", "\"post_proc_rules\"", "]", ":", "log", ".", "debug", "(", "(", "\"Found drop_columns={}\"", ")", ".", "format", "(", "meta_data", "[", "\"post_proc_rules\"", "]", "[", "\"drop_columns\"", "]", ")", ")", "for", "ign", "in", "meta_data", "[", "\"post_proc_rules\"", "]", "[", "\"drop_columns\"", "]", ":", "ignore_features", ".", "append", "(", "ign", ")", "except", "Exception", "as", "e", ":", "res", "[", "\"error\"", "]", "=", "(", "\"Failed building ignore_features: \"", "\"ignore_features={} meta={} meta_data={} \"", "\"last_step='{}' ex='{}'\"", ")", ".", "format", "(", "ignore_features", ",", "meta_file", ",", "meta_data", ",", "last_step", ",", "e", ")", "log", ".", "error", "(", "res", "[", "\"error\"", "]", ")", "res", "[", "\"status\"", "]", "=", "ERROR", "return", "res", "# end of trying to lookup the meta data file", "# for non-int/float features to ignore", "last_step", "=", "(", "\"metadata={} df has \"", "\"columns={} ignore={}\"", ")", ".", "format", "(", "meta_file", ",", "df", ".", "columns", ".", "values", ",", "ignore_features", ")", "log", ".", "info", "(", "last_step", ")", "for", "feature", "in", "df", ".", "columns", ".", "values", ":", "keep_it", "=", "True", "for", "ign", "in", "ignore_features", ":", "if", "feature", "==", "ign", ":", "keep_it", "=", "False", "if", "keep_it", ":", "if", "feature", "!=", "predict_feature", ":", "features_to_process", ".", "append", "(", "feature", ")", "# end of for all features to process", "last_step", "=", "(", "\"Done post-procecessing \"", "\"Predicting={} with features={} \"", "\"ignore_features={} records={}\"", ")", ".", "format", "(", "predict_feature", ",", "features_to_process", ",", "ignore_features", ",", "len", "(", "df", ".", "index", ")", ")", "log", ".", "info", "(", "last_step", ")", "res", "[", "\"predict_feature\"", "]", "=", "predict_feature", "res", "[", "\"ignore_features\"", "]", "=", "[", "]", "for", "k", "in", "ignore_features", ":", "if", "k", "not", "in", "res", "[", "\"ignore_features\"", "]", ":", "res", "[", "\"ignore_features\"", "]", ".", "append", "(", "k", ")", "res", "[", "\"features_to_process\"", "]", "=", "[", "]", "for", "k", "in", "features_to_process", ":", "if", "k", "not", "in", "res", "[", "\"features_to_process\"", "]", ":", "if", "k", "!=", "predict_feature", ":", "res", "[", "\"features_to_process\"", "]", ".", "append", "(", "k", ")", "# split the data into training", "(", "res", "[", "\"X_train\"", "]", ",", "res", "[", "\"X_test\"", "]", ",", "res", "[", "\"Y_train\"", "]", ",", "res", "[", "\"Y_test\"", "]", ")", "=", "train_test_split", "(", "df", "[", "features_to_process", "]", ",", "df", "[", "predict_feature", "]", ",", "test_size", "=", "test_size", ",", "random_state", "=", "res", "[", "\"seed\"", "]", ")", "last_step", "=", "(", "\"Done splitting rows={} into \"", "\"X_train={} X_test={} \"", "\"Y_train={} Y_test={}\"", ")", ".", "format", "(", "len", "(", "df", ".", "index", ")", ",", "len", "(", "res", "[", "\"X_train\"", "]", ")", ",", "len", "(", "res", "[", "\"X_test\"", "]", ")", ",", "len", "(", "res", "[", "\"Y_train\"", "]", ")", ",", "len", "(", "res", "[", "\"Y_test\"", "]", ")", ")", "log", ".", "info", "(", "(", "\"Success: {}\"", ")", ".", "format", "(", "last_step", ")", ")", "res", "[", "\"err\"", "]", "=", "\"\"", "res", "[", "\"status\"", "]", "=", "VALID", "except", "Exception", "as", "e", ":", "res", "[", "\"status\"", "]", "=", "ERROR", "res", "[", "\"err\"", "]", "=", "(", "\"Failed build_training_request \"", "\"step='{}' with ex='{}'\"", ")", ".", "format", "(", "last_step", ",", "e", ")", "log", ".", "error", "(", "(", "\"build_training_request: {}\"", ")", ".", "format", "(", "res", "[", "\"err\"", "]", ")", ")", "# end of try/ex", "return", "res" ]

[ "build_training_request" ]

[ "def", "_get_flag_group", "(", "h5f", ",", "path", ")", ":", "# if user chose the path, just use it", "if", "path", ":", "return", "h5f", "[", "path", "]", "# if the user gave us the group directly, use it", "if", "_is_flag_group", "(", "h5f", ")", ":", "return", "h5f", "# otherwise try and find a single group that matches", "try", ":", "path", ",", "=", "_find_flag_groups", "(", "h5f", ")", "except", "ValueError", ":", "pass", "else", ":", "return", "h5f", "[", "path", "]", "# if not exactly 1 valid group in the file, complain", "raise", "ValueError", "(", "\"please pass a valid HDF5 Group, or specify the HDF5 Group \"", "\"path via the ``path=`` keyword argument\"", ",", ")" ]

[ "Determine", "the", "group", "to", "use", "in", "order", "to", "read", "a", "flag" ]

[ "def", "unregister_engine", "(", "self", ",", "ident", ",", "msg", ")", ":", "try", ":", "eid", "=", "msg", "[", "'content'", "]", "[", "'id'", "]", "except", ":", "self", ".", "log", ".", "error", "(", "\"registration::bad engine id for unregistration: %r\"", ",", "ident", ",", "exc_info", "=", "True", ")", "return", "self", ".", "log", ".", "info", "(", "\"registration::unregister_engine(%r)\"", ",", "eid", ")", "# print (eid)", "uuid", "=", "self", ".", "keytable", "[", "eid", "]", "content", "=", "dict", "(", "id", "=", "eid", ",", "queue", "=", "uuid", ".", "decode", "(", "'ascii'", ")", ")", "self", ".", "dead_engines", ".", "add", "(", "uuid", ")", "# self.ids.remove(eid)", "# uuid = self.keytable.pop(eid)", "#", "# ec = self.engines.pop(eid)", "# self.hearts.pop(ec.heartbeat)", "# self.by_ident.pop(ec.queue)", "# self.completed.pop(eid)", "handleit", "=", "lambda", ":", "self", ".", "_handle_stranded_msgs", "(", "eid", ",", "uuid", ")", "dc", "=", "ioloop", ".", "DelayedCallback", "(", "handleit", ",", "self", ".", "registration_timeout", ",", "self", ".", "loop", ")", "dc", ".", "start", "(", ")", "############## TODO: HANDLE IT ################", "if", "self", ".", "notifier", ":", "self", ".", "session", ".", "send", "(", "self", ".", "notifier", ",", "\"unregistration_notification\"", ",", "content", "=", "content", ")" ]

[ "Unregister", "an", "engine", "that", "explicitly", "requested", "to", "leave", "." ]

[ "def", "get", "(", "self", ",", "name", "=", "None", ")", ":", "return", "self", ".", "__app", ".", "recipes", ".", "get", "(", "name", ",", "self", ".", "_plugin", ")" ]

[ "Gets", "a", "list", "of", "all", "recipes", "which", "are", "registered", "by", "the", "current", "plugin", ".", "If", "a", "name", "is", "provided", "only", "the", "requested", "recipe", "is", "returned", "or", "None", "." ]

[ "def", "respond", "(", "self", ",", "output", ")", ":", "response", "=", "{", "'exit_code'", ":", "output", ".", "code", ",", "'command_output'", ":", "output", ".", "log", "}", "self", ".", "send_response", "(", "200", ")", "self", ".", "send_header", "(", "'Content-type'", ",", "'application/json'", ")", "self", ".", "end_headers", "(", ")", "self", ".", "wfile", ".", "write", "(", "bytes", "(", "json", ".", "dumps", "(", "response", ")", ",", "\"utf8\"", ")", ")" ]

[ "Generates", "server", "response", "." ]

[ "def", "get_exception", "(", "self", ")", ":", "# type: () -> Optional[Tuple[Any, Any, Any]]", "with", "self", ".", "__lock", ":", "return", "(", "self", ".", "__updateexception", "if", "self", ".", "__updateexception", "or", "self", ".", "__closed", "else", "self", ".", "__exportref", ".", "get_exception", "(", ")", ")" ]

[ "Returns", "the", "exception", "associated", "to", "the", "export" ]

[ "def", "clean", "(", "self", ",", "value", ")", ":", "# If the value is None and it's optional, return as is", "if", "value", "is", "None", "and", "self", ".", "_optional", ":", "return", "None", "# Go through each of the nodes", "for", "i", "in", "range", "(", "len", "(", "self", ".", "_nodes", ")", ")", ":", "# If it's valid", "if", "self", ".", "_nodes", "[", "i", "]", ".", "valid", "(", "value", ")", ":", "# Use it's clean", "return", "self", ".", "_nodes", "[", "i", "]", ".", "clean", "(", "value", ")", "# Something went wrong", "raise", "ValueError", "(", "'value'", ",", "value", ")" ]

[ "Clean" ]

[ "def", "import_context", "(", "target_zip", ")", ":", "context_path", "=", "tasks", ".", "get_context_path", "(", ")", "with", "zipfile", ".", "ZipFile", "(", "target_zip", ")", "as", "unzipped_data", ":", "with", "open", "(", "context_path", ",", "'w'", ")", "as", "context", ":", "context", ".", "write", "(", "unzipped_data", ".", "read", "(", "'context.json'", ")", ")" ]

[ "Overwrite", "old", "context", ".", "json", "use", "context", ".", "json", "from", "target_zip", ":", "param", "target_zip", ":", ":", "return", ":" ]

[ "def", "clear_tc", "(", "self", ",", "owner", ",", "data", ",", "clear_type", ")", ":", "batch", "=", "self", ".", "tcex", ".", "batch", "(", "owner", ",", "action", "=", "'Delete'", ")", "tc_type", "=", "data", ".", "get", "(", "'type'", ")", "path", "=", "data", ".", "get", "(", "'path'", ")", "if", "tc_type", "in", "self", ".", "tcex", ".", "group_types", ":", "name", "=", "self", ".", "tcex", ".", "playbook", ".", "read", "(", "data", ".", "get", "(", "'name'", ")", ")", "name", "=", "self", ".", "path_data", "(", "name", ",", "path", ")", "if", "name", "is", "not", "None", ":", "print", "(", "'Deleting ThreatConnect Group: {}{}{}'", ".", "format", "(", "c", ".", "Style", ".", "BRIGHT", ",", "c", ".", "Fore", ".", "MAGENTA", ",", "name", ")", ")", "self", ".", "log", ".", "info", "(", "'[{}] Deleting ThreatConnect {} with name: {}.'", ".", "format", "(", "clear_type", ",", "tc_type", ",", "name", ")", ")", "batch", ".", "group", "(", "tc_type", ",", "name", ")", "elif", "tc_type", "in", "self", ".", "tcex", ".", "indicator_types", ":", "if", "data", ".", "get", "(", "'summary'", ")", "is", "not", "None", ":", "summary", "=", "self", ".", "tcex", ".", "playbook", ".", "read", "(", "data", ".", "get", "(", "'summary'", ")", ")", "else", ":", "resource", "=", "self", ".", "tcex", ".", "resource", "(", "tc_type", ")", "summary", "=", "resource", ".", "summary", "(", "data", ")", "summary", "=", "self", ".", "path_data", "(", "summary", ",", "path", ")", "if", "summary", "is", "not", "None", ":", "print", "(", "'Deleting ThreatConnect Indicator: {}{}{}'", ".", "format", "(", "c", ".", "Style", ".", "BRIGHT", ",", "c", ".", "Fore", ".", "MAGENTA", ",", "summary", ")", ")", "self", ".", "log", ".", "info", "(", "'[{}] Deleting ThreatConnect {} with value: {}.'", ".", "format", "(", "clear_type", ",", "tc_type", ",", "summary", ")", ")", "batch", ".", "indicator", "(", "tc_type", ",", "summary", ")", "batch_results", "=", "batch", ".", "submit", "(", ")", "self", ".", "log", ".", "debug", "(", "'[{}] Batch Results: {}'", ".", "format", "(", "clear_type", ",", "batch_results", ")", ")", "for", "error", "in", "batch_results", ".", "get", "(", "'errors'", ")", "or", "[", "]", ":", "self", ".", "log", ".", "error", "(", "'[{}] Batch Error: {}'", ".", "format", "(", "clear_type", ",", "error", ")", ")" ]

[ "Delete", "threat", "intel", "from", "ThreatConnect", "platform", "." ]

[ "def", "sub_menu", "(", "context", ",", "menuitem_or_page", ",", "use_specific", "=", "None", ",", "allow_repeating_parents", "=", "None", ",", "apply_active_classes", "=", "None", ",", "template", "=", "''", ",", "use_absolute_page_urls", "=", "None", ",", "add_sub_menus_inline", "=", "None", ",", "*", "*", "kwargs", ")", ":", "validate_supplied_values", "(", "'sub_menu'", ",", "use_specific", "=", "use_specific", ",", "menuitem_or_page", "=", "menuitem_or_page", ")", "max_levels", "=", "context", ".", "get", "(", "'max_levels'", ",", "settings", ".", "DEFAULT_CHILDREN_MENU_MAX_LEVELS", ")", "if", "use_specific", "is", "None", ":", "use_specific", "=", "context", ".", "get", "(", "'use_specific'", ",", "constants", ".", "USE_SPECIFIC_AUTO", ")", "if", "apply_active_classes", "is", "None", ":", "apply_active_classes", "=", "context", ".", "get", "(", "'apply_active_classes'", ",", "True", ")", "if", "allow_repeating_parents", "is", "None", ":", "allow_repeating_parents", "=", "context", ".", "get", "(", "'allow_repeating_parents'", ",", "True", ")", "if", "use_absolute_page_urls", "is", "None", ":", "use_absolute_page_urls", "=", "context", ".", "get", "(", "'use_absolute_page_urls'", ",", "False", ")", "if", "add_sub_menus_inline", "is", "None", ":", "add_sub_menus_inline", "=", "context", ".", "get", "(", "'add_sub_menus_inline'", ",", "False", ")", "if", "isinstance", "(", "menuitem_or_page", ",", "Page", ")", ":", "parent_page", "=", "menuitem_or_page", "else", ":", "parent_page", "=", "menuitem_or_page", ".", "link_page", "original_menu", "=", "context", ".", "get", "(", "'original_menu_instance'", ")", "if", "original_menu", "is", "None", ":", "raise", "SubMenuUsageError", "(", ")", "menu_class", "=", "original_menu", ".", "get_sub_menu_class", "(", ")", "return", "menu_class", ".", "render_from_tag", "(", "context", "=", "context", ",", "parent_page", "=", "parent_page", ",", "max_levels", "=", "max_levels", ",", "use_specific", "=", "use_specific", ",", "apply_active_classes", "=", "apply_active_classes", ",", "allow_repeating_parents", "=", "allow_repeating_parents", ",", "use_absolute_page_urls", "=", "use_absolute_page_urls", ",", "add_sub_menus_inline", "=", "add_sub_menus_inline", ",", "template_name", "=", "template", ",", "*", "*", "kwargs", ")" ]

[ "Retrieve", "the", "children", "pages", "for", "the", "menuitem_or_page", "provided", "turn", "them", "into", "menu", "items", "and", "render", "them", "to", "a", "template", "." ]

[ "def", "attributes", "(", "path", ")", ":", "# number of charcters set to numbers have changed in LAS AF X !!", "matches", "=", "re", ".", "findall", "(", "'--([A-Z]{1})([0-9]{2,4})'", ",", "path", ")", "keys", "=", "[", "]", "values", "=", "[", "]", "for", "k", ",", "v", "in", "matches", ":", "if", "k", "in", "keys", ":", "# keep only last key", "i", "=", "keys", ".", "index", "(", "k", ")", "del", "keys", "[", "i", "]", "del", "values", "[", "i", "]", "keys", ".", "append", "(", "k", ")", "values", ".", "append", "(", "v", ")", "lower_keys", "=", "[", "k", ".", "lower", "(", ")", "for", "k", "in", "keys", "]", "int_values", "=", "[", "int", "(", "v", ")", "for", "v", "in", "values", "]", "attributes", "=", "namedtuple", "(", "'attributes'", ",", "keys", "+", "lower_keys", ")", "return", "attributes", "(", "*", "values", "+", "int_values", ")" ]

[ "Get", "attributes", "from", "path", "based", "on", "format", "--", "[", "A", "-", "Z", "]", ".", "Returns", "namedtuple", "with", "upper", "case", "attributes", "equal", "to", "what", "found", "in", "path", "(", "string", ")", "and", "lower", "case", "as", "int", ".", "If", "path", "holds", "several", "occurrences", "of", "same", "character", "only", "the", "last", "one", "is", "kept", "." ]

[ "def", "write_reactions", "(", "self", ",", "stream", ",", "reactions", ",", "properties", "=", "None", ")", ":", "self", ".", "_write_entries", "(", "stream", ",", "reactions", ",", "self", ".", "convert_reaction_entry", ",", "properties", ")" ]

[ "Write", "iterable", "of", "reactions", "as", "YAML", "object", "to", "stream", "." ]

[ "def", "getShocks", "(", "self", ")", ":", "# The strange syntax here is so that both StickyEconsumerType and StickyEmarkovConsumerType", "# run the getShocks method of their first superclass: AggShockConsumerType and", "# AggShockMarkovConsumerType respectively. This will be simplified in Python 3.", "super", "(", "self", ".", "__class__", ",", "self", ")", ".", "getShocks", "(", ")", "# Get permanent and transitory combined shocks", "newborns", "=", "self", ".", "t_age", "==", "0", "self", ".", "TranShkNow", "[", "newborns", "]", "=", "self", ".", "TranShkAggNow", "*", "self", ".", "wRteNow", "# Turn off idiosyncratic shocks for newborns", "self", ".", "PermShkNow", "[", "newborns", "]", "=", "self", ".", "PermShkAggNow", "self", ".", "getUpdaters", "(", ")", "# Randomly draw which agents will update their beliefs", "# Calculate innovation to the productivity level perception error", "pLvlErrNew", "=", "self", ".", "getpLvlError", "(", ")", "self", ".", "pLvlErrNow", "*=", "pLvlErrNew", "# Perception error accumulation", "# Calculate (mis)perceptions of the permanent shock", "PermShkPcvd", "=", "self", ".", "PermShkNow", "/", "pLvlErrNew", "PermShkPcvd", "[", "self", ".", "update", "]", "*=", "self", ".", "pLvlErrNow", "[", "self", ".", "update", "]", "# Updaters see the true permanent shock and all missed news", "self", ".", "pLvlErrNow", "[", "self", ".", "update", "]", "=", "1.0", "self", ".", "PermShkNow", "=", "PermShkPcvd" ]

[ "Gets", "permanent", "and", "transitory", "shocks", "(", "combining", "idiosyncratic", "and", "aggregate", "shocks", ")", "but", "only", "consumers", "who", "update", "their", "macroeconomic", "beliefs", "this", "period", "incorporate", "all", "pre", "-", "viously", "unnoticed", "aggregate", "permanent", "shocks", ".", "Agents", "correctly", "observe", "the", "level", "of", "all", "real", "variables", "(", "market", "resources", "consumption", "assets", "etc", ")", "but", "misperceive", "the", "aggregate", "productivity", "level", "." ]

[ "def", "load_soil_sample_data", "(", "sp", ")", ":", "# soil", "sp", ".", "g_mod", "=", "60.0e6", "# [Pa]", "sp", ".", "phi", "=", "30", "# [degrees]", "sp", ".", "relative_density", "=", ".40", "# [decimal]", "sp", ".", "gwl", "=", "2.", "# [m], ground water level", "sp", ".", "unit_dry_weight", "=", "17000", "# [N/m3]", "sp", ".", "unit_sat_weight", "=", "18000", "# [N/m3]", "sp", ".", "unit_weight_water", "=", "9800", "# [N/m3]", "sp", ".", "cohesion", "=", "10.0", "# [Pa]", "sp", ".", "poissons_ratio", "=", "0.22", "sp", ".", "e_min", "=", "0.55", "sp", ".", "e_max", "=", "0.95", "sp", ".", "e_critical0", "=", "0.79", "# Jin et al. 2015", "sp", ".", "p_critical0", "=", "0.7", "# Jin et al. 2015", "sp", ".", "lamb_crl", "=", "0.015" ]

[ "Sample", "data", "for", "the", "Soil", "object", ":", "param", "sp", ":", "Soil", "Object", ":", "return", ":" ]

[ "def", "handle_event", "(", "self", ",", "event", ",", "client", ",", "args", ")", ":", "handler", "=", "self", ".", "event_handlers", ".", "get", "(", "event", ")", "if", "handler", ":", "return", "handler", "(", "client", ",", "*", "args", ")" ]

[ "Dispatch", "an", "event", "to", "its", "handler", "." ]

[ "def", "get_mean_and_stddevs", "(", "self", ",", "sites", ",", "rup", ",", "dists", ",", "imt", ",", "stddev_types", ")", ":", "# assign constant", "log10e", "=", "np", ".", "log10", "(", "np", ".", "e", ")", "# Distance term", "R", "=", "np", ".", "sqrt", "(", "dists", ".", "rjb", "**", "2", "+", "11.29", "**", "2", ")", "# Magnitude term", "M", "=", "rup", ".", "mag", "-", "6", "# Site term only distinguishes between lava and ash;", "# since ash sites have Vs30 in the range 60-200m/s,", "# we use this upper value as class separator", "S", "=", "np", ".", "zeros", "(", "R", ".", "shape", ")", "S", "[", "sites", ".", "vs30", "<=", "200", "]", "=", "1", "# Mean ground motion (natural log)", "# call super", "mean", ",", "stddevs", "=", "super", "(", ")", ".", "get_mean_and_stddevs", "(", "sites", ",", "rup", ",", "dists", ",", "imt", ",", "stddev_types", ")", "if", "rup", ".", "mag", ">", "7.", "and", "rup", ".", "mag", "<=", "7.7", ":", "mean", "=", "(", "0.171", "*", "(", "1", "-", "M", ")", ")", "/", "log10e", "+", "mean", "elif", "rup", ".", "mag", ">", "7.7", ":", "mean", "=", "(", "0.1512", "+", "0.387", "*", "(", "1", "-", "M", ")", ")", "/", "log10e", "+", "mean", "# define natural log of SA 0.3 sec and 0.2 sec", "if", "isinstance", "(", "imt", ",", "SA", ")", ":", "if", "imt", ".", "period", "==", "0.3", ":", "mean", "=", "np", ".", "log", "(", "2.2", ")", "+", "mean", "if", "imt", ".", "period", "==", "0.2", ":", "mean", "=", "np", ".", "log", "(", "2.5", ")", "+", "mean", "return", "mean", ",", "stddevs" ]

[ "See", ":", "meth", ":", "superclass", "method", "<", ".", "base", ".", "GroundShakingIntensityModel", ".", "get_mean_and_stddevs", ">", "for", "spec", "of", "input", "and", "result", "values", "." ]

[ "def", "copy_object", "(", "self", ",", "container", ",", "obj", ",", "new_container", ",", "new_obj_name", "=", "None", ",", "content_type", "=", "None", ")", ":", "nm", "=", "new_obj_name", "or", "utils", ".", "get_name", "(", "obj", ")", "uri", "=", "\"/%s/%s\"", "%", "(", "utils", ".", "get_name", "(", "new_container", ")", ",", "nm", ")", "copy_from", "=", "\"/%s/%s\"", "%", "(", "utils", ".", "get_name", "(", "container", ")", ",", "utils", ".", "get_name", "(", "obj", ")", ")", "headers", "=", "{", "\"X-Copy-From\"", ":", "copy_from", ",", "\"Content-Length\"", ":", "\"0\"", "}", "if", "content_type", ":", "headers", "[", "\"Content-Type\"", "]", "=", "content_type", "resp", ",", "resp_body", "=", "self", ".", "api", ".", "method_put", "(", "uri", ",", "headers", "=", "headers", ")", "return", "resp", ".", "headers", ".", "get", "(", "\"etag\"", ")" ]

[ "Copies", "the", "object", "to", "the", "new", "container", "optionally", "giving", "it", "a", "new", "name", ".", "If", "you", "copy", "to", "the", "same", "container", "you", "must", "supply", "a", "different", "name", "." ]

[ "def", "download_dxfile", "(", "dxid", ",", "filename", ",", "chunksize", "=", "dxfile", ".", "DEFAULT_BUFFER_SIZE", ",", "append", "=", "False", ",", "show_progress", "=", "False", ",", "project", "=", "None", ",", "describe_output", "=", "None", ",", "*", "*", "kwargs", ")", ":", "# retry the inner loop while there are retriable errors", "part_retry_counter", "=", "defaultdict", "(", "lambda", ":", "3", ")", "success", "=", "False", "while", "not", "success", ":", "success", "=", "_download_dxfile", "(", "dxid", ",", "filename", ",", "part_retry_counter", ",", "chunksize", "=", "chunksize", ",", "append", "=", "append", ",", "show_progress", "=", "show_progress", ",", "project", "=", "project", ",", "describe_output", "=", "describe_output", ",", "*", "*", "kwargs", ")" ]

[ ":", "param", "dxid", ":", "DNAnexus", "file", "ID", "or", "DXFile", "(", "file", "handler", ")", "object", ":", "type", "dxid", ":", "string", "or", "DXFile", ":", "param", "filename", ":", "Local", "filename", ":", "type", "filename", ":", "string", ":", "param", "append", ":", "If", "True", "appends", "to", "the", "local", "file", "(", "default", "is", "to", "truncate", "local", "file", "if", "it", "exists", ")", ":", "type", "append", ":", "boolean", ":", "param", "project", ":", "project", "to", "use", "as", "context", "for", "this", "download", "(", "may", "affect", "which", "billing", "account", "is", "billed", "for", "this", "download", ")", ".", "If", "None", "or", "DXFile", ".", "NO_PROJECT_HINT", "no", "project", "hint", "is", "supplied", "to", "the", "API", "server", ".", ":", "type", "project", ":", "str", "or", "None", ":", "param", "describe_output", ":", "(", "experimental", ")", "output", "of", "the", "file", "-", "xxxx", "/", "describe", "API", "call", "if", "available", ".", "It", "will", "make", "it", "possible", "to", "skip", "another", "describe", "API", "call", ".", "It", "should", "contain", "the", "default", "fields", "of", "the", "describe", "API", "call", "output", "and", "the", "parts", "field", "not", "included", "in", "the", "output", "by", "default", ".", ":", "type", "describe_output", ":", "dict", "or", "None" ]

[ "def", "deserialize_logical", "(", "self", ",", "node", ")", ":", "term1_attrib", "=", "node", ".", "getAttribute", "(", "'left-field'", ")", "term1_value", "=", "node", ".", "getAttribute", "(", "'left-value'", ")", "op", "=", "node", ".", "nodeName", ".", "lower", "(", ")", "term2_attrib", "=", "node", ".", "getAttribute", "(", "'right-field'", ")", "term2_value", "=", "node", ".", "getAttribute", "(", "'right-value'", ")", "if", "op", "not", "in", "_op_map", ":", "_exc", "(", "'Invalid operator'", ")", "if", "term1_attrib", "!=", "''", "and", "term1_value", "!=", "''", ":", "_exc", "(", "'Both, left-field and left-value attributes found'", ")", "elif", "term1_attrib", "==", "''", "and", "term1_value", "==", "''", ":", "_exc", "(", "'left-field or left-value attribute required'", ")", "elif", "term1_value", "!=", "''", ":", "left", "=", "term1_value", "else", ":", "left", "=", "operators", ".", "Attrib", "(", "term1_attrib", ")", "if", "term2_attrib", "!=", "''", "and", "term2_value", "!=", "''", ":", "_exc", "(", "'Both, right-field and right-value attributes found'", ")", "elif", "term2_attrib", "==", "''", "and", "term2_value", "==", "''", ":", "_exc", "(", "'right-field or right-value attribute required'", ")", "elif", "term2_value", "!=", "''", ":", "right", "=", "term2_value", "else", ":", "right", "=", "operators", ".", "Attrib", "(", "term2_attrib", ")", "return", "_op_map", "[", "op", "]", "(", "left", ",", "right", ")" ]

[ "Reads", "the", "logical", "tag", "from", "the", "given", "node", "returns", "a", "Condition", "object", "." ]

[ "def", "label_TM_tmhmm_residue_numbers_and_leaflets", "(", "tmhmm_seq", ")", ":", "TM_number_dict", "=", "{", "}", "T_index", "=", "[", "]", "T_residue", "=", "[", "]", "residue_count", "=", "1", "for", "residue_label", "in", "tmhmm_seq", ":", "if", "residue_label", "==", "'T'", ":", "T_residue", ".", "append", "(", "residue_count", ")", "residue_count", "=", "residue_count", "+", "1", "TM_number_dict", ".", "update", "(", "{", "'T_residue'", ":", "T_residue", "}", ")", "# finding the TM boundaries", "T_residue_list", "=", "TM_number_dict", "[", "'T_residue'", "]", "count", "=", "0", "max_count", "=", "len", "(", "T_residue_list", ")", "-", "1", "TM_helix_count", "=", "0", "TM_boundary_dict", "=", "{", "}", "while", "count", "<=", "max_count", ":", "# first residue = TM start", "if", "count", "==", "0", ":", "TM_start", "=", "T_residue_list", "[", "count", "]", "count", "=", "count", "+", "1", "continue", "# Last residue = TM end", "elif", "count", "==", "max_count", ":", "TM_end", "=", "T_residue_list", "[", "count", "]", "TM_helix_count", "=", "TM_helix_count", "+", "1", "TM_boundary_dict", ".", "update", "(", "{", "'TM_helix_'", "+", "str", "(", "TM_helix_count", ")", ":", "[", "TM_start", ",", "TM_end", "]", "}", ")", "break", "# middle residues need to be start or end", "elif", "T_residue_list", "[", "count", "]", "!=", "T_residue_list", "[", "count", "+", "1", "]", "-", "1", ":", "TM_end", "=", "T_residue_list", "[", "count", "]", "TM_helix_count", "=", "TM_helix_count", "+", "1", "TM_boundary_dict", ".", "update", "(", "{", "'TM_helix_'", "+", "str", "(", "TM_helix_count", ")", ":", "[", "TM_start", ",", "TM_end", "]", "}", ")", "# new TM_start", "TM_start", "=", "T_residue_list", "[", "count", "+", "1", "]", "count", "=", "count", "+", "1", "# assign leaflet to proper TM residues O or I", "leaflet_dict", "=", "{", "}", "for", "leaflet", "in", "[", "'O'", ",", "'I'", "]", ":", "leaflet_list", "=", "[", "]", "for", "TM_helix", ",", "TM_residues", "in", "TM_boundary_dict", ".", "items", "(", ")", ":", "for", "residue_num", "in", "TM_residues", ":", "tmhmm_seq_index", "=", "residue_num", "-", "1", "previous_residue", "=", "tmhmm_seq_index", "-", "1", "next_residue", "=", "tmhmm_seq_index", "+", "1", "# identify if the previous or next residue closest to the TM helix start/end is the proper leaflet", "if", "tmhmm_seq", "[", "previous_residue", "]", "==", "leaflet", "or", "tmhmm_seq", "[", "next_residue", "]", "==", "leaflet", ":", "leaflet_list", ".", "append", "(", "residue_num", ")", "leaflet_dict", ".", "update", "(", "{", "'tmhmm_leaflet_'", "+", "leaflet", ":", "leaflet_list", "}", ")", "return", "TM_boundary_dict", ",", "leaflet_dict" ]

[ "Determine", "the", "residue", "numbers", "of", "the", "TM", "-", "helix", "residues", "that", "cross", "the", "membrane", "and", "label", "them", "by", "leaflet", "." ]

[ "def", "common_criteria", "(", "*", "*", "common", ")", ":", "def", "decorator", "(", "func", ")", ":", "def", "inner", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "merged_kwargs", "=", "copy", "(", "common", ")", "merged_kwargs", ".", "update", "(", "kwargs", ")", "return", "func", "(", "*", "args", ",", "*", "*", "merged_kwargs", ")", "return", "inner", "return", "decorator" ]

[ "Wrap", "a", "function", "to", "always", "call", "with", "the", "given", "common", "named", "parameters", "." ]

[ "def", "_encode_decode_decorator", "(", "func", ")", ":", "def", "wrapper", "(", "*", "args", ")", ":", "\"\"\"error catching\"\"\"", "try", ":", "processed_geom", "=", "func", "(", "*", "args", ")", "return", "processed_geom", "except", "ImportError", "as", "err", ":", "raise", "ImportError", "(", "'The Python package `shapely` needs to be '", "'installed to encode or decode geometries. '", "'({})'", ".", "format", "(", "err", ")", ")", "return", "wrapper" ]

[ "decorator", "for", "encoding", "and", "decoding", "geoms" ]

[ "def", "get_deepest_subsumer", "(", "self", ",", "list_terms", ")", ":", "#To store with how many terms every nonterminal appears", "count_per_no_terminal", "=", "defaultdict", "(", "int", ")", "#To store the total deep of each noter for all the term ides (as we want the deepest)", "total_deep_per_no_terminal", "=", "defaultdict", "(", "int", ")", "for", "term_id", "in", "list_terms", ":", "terminal_id", "=", "self", ".", "terminal_for_term", ".", "get", "(", "term_id", ")", "path", "=", "self", ".", "paths_for_terminal", "[", "terminal_id", "]", "[", "0", "]", "print", "(", "term_id", ",", "path", ")", "for", "c", ",", "noter", "in", "enumerate", "(", "path", ")", ":", "count_per_no_terminal", "[", "noter", "]", "+=", "1", "total_deep_per_no_terminal", "[", "noter", "]", "+=", "c", "deepest_and_common", "=", "None", "deepest", "=", "10000", "for", "noterid", ",", "this_total", "in", "total_deep_per_no_terminal", ".", "items", "(", ")", ":", "if", "count_per_no_terminal", ".", "get", "(", "noterid", ",", "-", "1", ")", "==", "len", "(", "list_terms", ")", ":", "##Only the nontarms that ocurr with all the term ids in the input", "if", "this_total", "<", "deepest", ":", "deepest", "=", "this_total", "deepest_and_common", "=", "noterid", "label", "=", "None", "if", "deepest_and_common", "is", "not", "None", ":", "label", "=", "self", ".", "label_for_nonter", "[", "deepest_and_common", "]", "return", "deepest_and_common", ",", "label" ]

[ "Returns", "the", "labels", "of", "the", "deepest", "node", "that", "subsumes", "all", "the", "terms", "in", "the", "list", "of", "terms", "id", "s", "provided" ]

[ "def", "_process_underscores", "(", "self", ",", "tokens", ")", ":", "groups", "=", "[", "[", "str", "(", "''", ".", "join", "(", "el", ")", ")", "]", "if", "b", "else", "list", "(", "el", ")", "for", "(", "b", ",", "el", ")", "in", "itertools", ".", "groupby", "(", "tokens", ",", "lambda", "k", ":", "k", "==", "'_'", ")", "]", "flattened", "=", "[", "el", "for", "group", "in", "groups", "for", "el", "in", "group", "]", "processed", "=", "[", "]", "for", "token", "in", "flattened", ":", "if", "token", "==", "'_'", ":", "continue", "if", "token", ".", "startswith", "(", "'_'", ")", ":", "token", "=", "str", "(", "token", "[", "1", ":", "]", ")", "if", "token", ".", "endswith", "(", "'_'", ")", ":", "token", "=", "str", "(", "token", "[", ":", "-", "1", "]", ")", "processed", ".", "append", "(", "token", ")", "return", "processed" ]

[ "Strip", "underscores", "to", "make", "sure", "the", "number", "is", "correct", "after", "join" ]

[ "def", "lock", "(", "resources", ",", "*", "args", ",", "*", "*", "kwargs", ")", ":", "# all resources are locked if nothing is specified", "if", "not", "resources", ":", "client", "=", "redis", ".", "Redis", "(", "decode_responses", "=", "True", ",", "*", "*", "kwargs", ")", "resources", "=", "find_resources", "(", "client", ")", "if", "not", "resources", ":", "return", "# create one process per pid", "locker", "=", "Locker", "(", "*", "*", "kwargs", ")", "while", "len", "(", "resources", ")", ">", "1", ":", "pid", "=", "os", ".", "fork", "(", ")", "resources", "=", "resources", "[", ":", "1", "]", "if", "pid", "else", "resources", "[", "1", ":", "]", "# at this point there is only one resource - lock it down", "resource", "=", "resources", "[", "0", "]", "try", ":", "print", "(", "'{}: acquiring'", ".", "format", "(", "resource", ")", ")", "with", "locker", ".", "lock", "(", "resource", ",", "label", "=", "'lock tool'", ")", ":", "print", "(", "'{}: locked'", ".", "format", "(", "resource", ")", ")", "try", ":", "signal", ".", "pause", "(", ")", "except", "KeyboardInterrupt", ":", "print", "(", "'{}: released'", ".", "format", "(", "resource", ")", ")", "except", "KeyboardInterrupt", ":", "print", "(", "'{}: canceled'", ".", "format", "(", "resource", ")", ")" ]

[ "Lock", "resources", "from", "the", "command", "line", "for", "example", "for", "maintenance", "." ]

[ "def", "find", "(", "self", ",", "name", "=", "None", ",", "*", "*", "attrs", ")", ":", "try", ":", "return", "next", "(", "self", ".", "find_all", "(", "name", ",", "*", "*", "attrs", ")", ")", "except", "StopIteration", ":", "return", "None" ]

[ "r", "First", "descendant", "node", "matching", "criteria", "." ]

[ "def", "deserialize", "(", "cls", ",", "target_class", ",", "obj", ")", ":", "installation_context", "=", "target_class", ".", "__new__", "(", "target_class", ")", "private_key_client", "=", "security", ".", "rsa_key_from_string", "(", "obj", "[", "cls", ".", "_FIELD_PRIVATE_KEY_CLIENT", "]", ")", "public_key_client", "=", "security", ".", "rsa_key_from_string", "(", "obj", "[", "cls", ".", "_FIELD_PUBLIC_KEY_CLIENT", "]", ")", "public_key_server", "=", "security", ".", "rsa_key_from_string", "(", "obj", "[", "cls", ".", "_FIELD_PUBLIC_KEY_SERVER", "]", ")", "installation_context", ".", "__dict__", "=", "{", "cls", ".", "_ATTRIBUTE_TOKEN", ":", "obj", "[", "cls", ".", "_FIELD_TOKEN", "]", ",", "cls", ".", "_ATTRIBUTE_PRIVATE_KEY_CLIENT", ":", "private_key_client", ",", "cls", ".", "_ATTRIBUTE_PUBLIC_KEY_CLIENT", ":", "public_key_client", ",", "cls", ".", "_ATTRIBUTE_PUBLIC_KEY_SERVER", ":", "public_key_server", ",", "}", "return", "installation_context" ]

[ ":", "type", "target_class", ":", "context", ".", "InstallationContext|type", ":", "type", "obj", ":", "dict" ]

[ "def", "mt_deconvolve", "(", "data_a", ",", "data_b", ",", "delta", ",", "nfft", "=", "None", ",", "time_bandwidth", "=", "None", ",", "number_of_tapers", "=", "None", ",", "weights", "=", "\"adaptive\"", ",", "demean", "=", "True", ",", "fmax", "=", "0.0", ")", ":", "npts", "=", "len", "(", "data_a", ")", "if", "len", "(", "data_b", ")", "!=", "npts", ":", "raise", "ValueError", "(", "\"Input arrays must have the same length!\"", ")", "if", "nfft", "is", "None", ":", "nfft", "=", "npts", "elif", "nfft", "<", "npts", ":", "raise", "ValueError", "(", "\"nfft must be larger then the number of samples in \"", "\"the array.\"", ")", "# Deconvolution utilizes the 32bit version.", "mt", "=", "_MtspecType", "(", "\"float32\"", ")", "# Use the optimal number of tapers in case no number is specified.", "if", "number_of_tapers", "is", "None", ":", "number_of_tapers", "=", "int", "(", "2", "*", "time_bandwidth", ")", "-", "1", "# Transform the data to work with the library.", "data_a", "=", "np", ".", "require", "(", "data_a", ",", "mt", ".", "float", ",", "requirements", "=", "[", "mt", ".", "order", "]", ")", "data_b", "=", "np", ".", "require", "(", "data_b", ",", "mt", ".", "float", ",", "requirements", "=", "[", "mt", ".", "order", "]", ")", "nf", "=", "nfft", "//", "2", "+", "1", "# Internally uses integers", "if", "demean", ":", "demean", "=", "1", "else", ":", "demean", "=", "0", "# iad = 0 are adaptive, iad = 1 are constant weight - this is", "# counter intuitive.", "if", "weights", "==", "\"constant\"", ":", "adaptive", "=", "1", "elif", "weights", "==", "\"adaptive\"", ":", "adaptive", "=", "0", "else", ":", "raise", "ValueError", "(", "'Weights must be either \"adaptive\" or \"constant\".'", ")", "tfun", "=", "mt", ".", "empty", "(", "nfft", ")", "freq", "=", "mt", ".", "empty", "(", "nf", ")", "spec_ratio", "=", "mt", ".", "empty", "(", "nf", ")", "speci", "=", "mt", ".", "empty", "(", "nf", ")", "specj", "=", "mt", ".", "empty", "(", "nf", ")", "mtspeclib", ".", "mt_deconv_", "(", "C", ".", "byref", "(", "C", ".", "c_int", "(", "int", "(", "npts", ")", ")", ")", ",", "C", ".", "byref", "(", "C", ".", "c_int", "(", "int", "(", "nfft", ")", ")", ")", ",", "C", ".", "byref", "(", "C", ".", "c_float", "(", "float", "(", "delta", ")", ")", ")", ",", "mt", ".", "p", "(", "data_a", ")", ",", "mt", ".", "p", "(", "data_b", ")", ",", "C", ".", "byref", "(", "C", ".", "c_float", "(", "float", "(", "time_bandwidth", ")", ")", ")", ",", "C", ".", "byref", "(", "C", ".", "c_int", "(", "int", "(", "number_of_tapers", ")", ")", ")", ",", "C", ".", "byref", "(", "C", ".", "c_int", "(", "int", "(", "nf", ")", ")", ")", ",", "C", ".", "byref", "(", "C", ".", "c_int", "(", "adaptive", ")", ")", ",", "mt", ".", "p", "(", "freq", ")", ",", "mt", ".", "p", "(", "tfun", ")", ",", "mt", ".", "p", "(", "spec_ratio", ")", ",", "mt", ".", "p", "(", "speci", ")", ",", "mt", ".", "p", "(", "specj", ")", ",", "C", ".", "byref", "(", "C", ".", "c_int", "(", "demean", ")", ")", ",", "C", ".", "byref", "(", "C", ".", "c_float", "(", "fmax", ")", ")", ")", "return", "{", "\"frequencies\"", ":", "freq", ",", "\"deconvolved\"", ":", "tfun", ",", "\"spectral_ratio\"", ":", "spec_ratio", ",", "\"spectrum_a\"", ":", "speci", ",", "\"spectrum_b\"", ":", "specj", "}" ]

[ "Deconvolve", "two", "time", "series", "using", "multitapers", "." ]

[ "def", "is_disconnected", "(", "self", ",", "node_id", ")", ":", "conn", "=", "self", ".", "_conns", ".", "get", "(", "node_id", ")", "if", "conn", "is", "None", ":", "return", "False", "return", "conn", ".", "disconnected", "(", ")" ]

[ "Check", "whether", "the", "node", "connection", "has", "been", "disconnected", "or", "failed", "." ]

[ "def", "add_proxy", "(", "self", ",", "proxy", ")", ":", "protocol", "=", "proxy", ".", "protocol", "addr", "=", "proxy", ".", "addr", "if", "addr", "in", "self", ".", "proxies", ":", "self", ".", "proxies", "[", "protocol", "]", "[", "addr", "]", ".", "last_checked", "=", "proxy", ".", "last_checked", "else", ":", "self", ".", "proxies", "[", "protocol", "]", "[", "addr", "]", "=", "proxy", "self", ".", "addr_list", "[", "protocol", "]", ".", "append", "(", "addr", ")" ]

[ "Add", "a", "valid", "proxy", "into", "pool" ]

[ "def", "get", "(", "self", ",", "timeout", "=", "None", ")", ":", "valid", "=", "False", "result", "=", "None", "for", "tube", "in", "self", ".", "_output_tubes", ":", "if", "timeout", ":", "valid", ",", "result", "=", "tube", ".", "get", "(", "timeout", ")", "if", "valid", ":", "result", "=", "result", "[", "0", "]", "else", ":", "result", "=", "tube", ".", "get", "(", ")", "[", "0", "]", "if", "timeout", ":", "return", "valid", ",", "result", "return", "result" ]

[ "Retrieve", "results", "from", "all", "the", "output", "tubes", "." ]

[ "def", "set_lowest_numeric_score", "(", "self", ",", "score", ")", ":", "# Implemented from template for osid.grading.GradeSystemForm.set_lowest_numeric_score", "if", "self", ".", "get_lowest_numeric_score_metadata", "(", ")", ".", "is_read_only", "(", ")", ":", "raise", "errors", ".", "NoAccess", "(", ")", "try", ":", "score", "=", "float", "(", "score", ")", "except", "ValueError", ":", "raise", "errors", ".", "InvalidArgument", "(", ")", "if", "not", "self", ".", "_is_valid_decimal", "(", "score", ",", "self", ".", "get_lowest_numeric_score_metadata", "(", ")", ")", ":", "raise", "errors", ".", "InvalidArgument", "(", ")", "self", ".", "_my_map", "[", "'lowestNumericScore'", "]", "=", "score" ]

[ "Sets", "the", "lowest", "numeric", "score", "." ]

[ "def", "user_loggedin", "(", "sender", ",", "*", "*", "kwargs", ")", ":", "values", "=", "{", "'value'", ":", "1", ",", "'path'", ":", "kwargs", "[", "'request'", "]", ".", "path", ",", "'user_id'", ":", "str", "(", "kwargs", "[", "'user'", "]", ".", "pk", ")", ",", "'username'", ":", "kwargs", "[", "'user'", "]", ".", "username", ",", "}", "write", "(", "'user_logins'", ",", "values", "=", "values", ")" ]

[ "collect", "metrics", "about", "user", "logins" ]

[ "def", "parse_hashes", "(", "self", ")", ":", "# type: () -> None", "line", ",", "hashes", "=", "self", ".", "split_hashes", "(", "self", ".", "line", ")", "self", ".", "hashes", "=", "hashes", "self", ".", "line", "=", "line" ]

[ "Parse", "hashes", "from", "*", "self", ".", "line", "*", "and", "set", "them", "on", "the", "current", "object", ".", ":", "returns", ":", "Nothing", ":", "rtype", ":", "None" ]

[ "def", "get_time_series", "(", "sdat", ",", "var", ",", "tstart", ",", "tend", ")", ":", "tseries", "=", "sdat", ".", "tseries_between", "(", "tstart", ",", "tend", ")", "if", "var", "in", "tseries", ".", "columns", ":", "series", "=", "tseries", "[", "var", "]", "time", "=", "None", "if", "var", "in", "phyvars", ".", "TIME", ":", "meta", "=", "phyvars", ".", "TIME", "[", "var", "]", "else", ":", "meta", "=", "phyvars", ".", "Vart", "(", "var", ",", "None", ",", "'1'", ")", "elif", "var", "in", "phyvars", ".", "TIME_EXTRA", ":", "meta", "=", "phyvars", ".", "TIME_EXTRA", "[", "var", "]", "series", ",", "time", "=", "meta", ".", "description", "(", "sdat", ",", "tstart", ",", "tend", ")", "meta", "=", "phyvars", ".", "Vart", "(", "misc", ".", "baredoc", "(", "meta", ".", "description", ")", ",", "meta", ".", "kind", ",", "meta", ".", "dim", ")", "else", ":", "raise", "UnknownTimeVarError", "(", "var", ")", "series", ",", "_", "=", "sdat", ".", "scale", "(", "series", ",", "meta", ".", "dim", ")", "if", "time", "is", "not", "None", ":", "time", ",", "_", "=", "sdat", ".", "scale", "(", "time", ",", "'s'", ")", "return", "series", ",", "time", ",", "meta" ]

[ "Extract", "or", "compute", "and", "rescale", "a", "time", "series", "." ]

[ "def", "add_partition", "(", "self", ",", "p", ")", ":", "if", "not", "self", ".", "partitions", ":", "self", ".", "partitions", "=", "{", "}", "self", ".", "partitions", "[", "p", ".", "vid", "]", "=", "p" ]

[ "Add", "a", "partition", "identity", "as", "a", "child", "of", "a", "dataset", "identity", "." ]

[ "def", "__info_gzip_gen", "(", "self", ")", ":", "self", ".", "__generating", "=", "True", "inflate", "=", "zlib", ".", "decompressobj", "(", "15", "+", "32", ")", "done", ",", "buf", "=", "False", ",", "fifo", ".", "Fifo", "(", ")", "while", "not", "done", ":", "try", ":", "data", "=", "inflate", ".", "decompress", "(", "next", "(", "self", ".", "__buf_gen", "(", ")", ")", ")", "except", "zlib", ".", "error", ":", "raise", "NNTPDataError", "(", "\"Decompression failed\"", ")", "if", "data", ":", "buf", ".", "write", "(", "data", ")", "if", "inflate", ".", "unused_data", ":", "buf", ".", "write", "(", "inflate", ".", "unused_data", ")", "for", "line", "in", "buf", ":", "if", "line", "==", "\".\\r\\n\"", ":", "done", "=", "True", "break", "if", "line", ".", "startswith", "(", "\".\"", ")", ":", "yield", "line", "[", "1", ":", "]", "yield", "line", "self", ".", "__generating", "=", "False" ]

[ "Generator", "for", "the", "lines", "of", "a", "compressed", "info", "(", "textual", ")", "response", "." ]

[ "def", "get_identities", "(", "self", ",", "item", ")", ":", "item", "=", "item", "[", "'data'", "]", "for", "field", "in", "[", "\"assignee\"", ",", "\"reporter\"", ",", "\"creator\"", "]", ":", "if", "field", "not", "in", "item", "[", "\"fields\"", "]", ":", "continue", "if", "item", "[", "\"fields\"", "]", "[", "field", "]", ":", "user", "=", "self", ".", "get_sh_identity", "(", "item", "[", "\"fields\"", "]", "[", "field", "]", ")", "yield", "user", "comments", "=", "item", ".", "get", "(", "'comments_data'", ",", "[", "]", ")", "for", "comment", "in", "comments", ":", "if", "'author'", "in", "comment", "and", "comment", "[", "'author'", "]", ":", "user", "=", "self", ".", "get_sh_identity", "(", "comment", "[", "'author'", "]", ")", "yield", "user", "if", "'updateAuthor'", "in", "comment", "and", "comment", "[", "'updateAuthor'", "]", ":", "user", "=", "self", ".", "get_sh_identity", "(", "comment", "[", "'updateAuthor'", "]", ")", "yield", "user" ]

[ "Return", "the", "identities", "from", "an", "item" ]

[ "def", "genl_send_simple", "(", "sk", ",", "family", ",", "cmd", ",", "version", ",", "flags", ")", ":", "hdr", "=", "genlmsghdr", "(", "cmd", "=", "cmd", ",", "version", "=", "version", ")", "return", "int", "(", "nl_send_simple", "(", "sk", ",", "family", ",", "flags", ",", "hdr", ",", "hdr", ".", "SIZEOF", ")", ")" ]

[ "Send", "a", "Generic", "Netlink", "message", "consisting", "only", "of", "a", "header", "." ]

[ "def", "run", "(", "self", ")", ":", "# We left-append rather than emit (right-append) because some message", "# may have been already queued for execution before the director runs.", "global_event_queue", ".", "appendleft", "(", "(", "INITIATE", ",", "self", ",", "(", ")", ",", "{", "}", ")", ")", "while", "global_event_queue", ":", "self", ".", "process_event", "(", "global_event_queue", ".", "popleft", "(", ")", ")" ]

[ "Run", "until", "there", "are", "no", "events", "to", "be", "processed", "." ]

[ "def", "load_application", "(", "self", ",", "*", "args", ",", "*", "*", "kwargs", ")", ":", "# Get keyword arguments", "app_id", "=", "kwargs", ".", "pop", "(", "\"app_id\"", ")", "wait", "=", "kwargs", ".", "pop", "(", "\"wait\"", ")", "n_tries", "=", "kwargs", ".", "pop", "(", "\"n_tries\"", ")", "app_start_delay", "=", "kwargs", ".", "pop", "(", "\"app_start_delay\"", ")", "use_count", "=", "kwargs", ".", "pop", "(", "\"use_count\"", ",", "True", ")", "# Coerce the arguments into a single form. If there are two arguments", "# then assume that we have filename and a map of chips and cores;", "# otherwise there should be ONE argument which is of the form of the", "# return value of `build_application_map`.", "application_map", "=", "{", "}", "if", "len", "(", "args", ")", "==", "1", ":", "application_map", "=", "args", "[", "0", "]", "elif", "len", "(", "args", ")", "==", "2", ":", "application_map", "=", "{", "args", "[", "0", "]", ":", "args", "[", "1", "]", "}", "else", ":", "raise", "TypeError", "(", "\"load_application: accepts either 1 or 2 positional arguments:\"", "\"a map of filenames to targets OR a single filename and its\"", "\"targets\"", ")", "# Count the number of cores being loaded", "core_count", "=", "sum", "(", "len", "(", "cores", ")", "for", "ts", "in", "six", ".", "itervalues", "(", "application_map", ")", "for", "cores", "in", "six", ".", "itervalues", "(", "ts", ")", ")", "# Mark all targets as unloaded", "unloaded", "=", "application_map", "# Try to load the applications, then determine which are unloaded", "tries", "=", "0", "while", "unloaded", "!=", "{", "}", "and", "tries", "<=", "n_tries", ":", "tries", "+=", "1", "# Load all unloaded applications, then pause to ensure they reach", "# the wait state", "self", ".", "flood_fill_aplx", "(", "unloaded", ",", "app_id", "=", "app_id", ",", "wait", "=", "True", ")", "time", ".", "sleep", "(", "app_start_delay", ")", "# If running in \"fast\" mode then check that the correct number of", "# cores are in the \"wait\" state, if so then break out of this loop.", "if", "(", "use_count", "and", "core_count", "==", "self", ".", "count_cores_in_state", "(", "\"wait\"", ",", "app_id", ")", ")", ":", "unloaded", "=", "{", "}", "continue", "# Query each target in turn to determine if it is loaded or", "# otherwise. If it is loaded (in the wait state) then remove it", "# from the unloaded list.", "new_unloadeds", "=", "dict", "(", ")", "for", "app_name", ",", "targets", "in", "iteritems", "(", "unloaded", ")", ":", "unloaded_targets", "=", "{", "}", "for", "(", "x", ",", "y", ")", ",", "cores", "in", "iteritems", "(", "targets", ")", ":", "unloaded_cores", "=", "set", "(", ")", "for", "p", "in", "cores", ":", "# Read the struct value vcpu->cpu_state, if it is", "# anything BUT wait then we mark this core as unloaded.", "state", "=", "consts", ".", "AppState", "(", "self", ".", "read_vcpu_struct_field", "(", "\"cpu_state\"", ",", "x", ",", "y", ",", "p", ")", ")", "if", "state", "is", "not", "consts", ".", "AppState", ".", "wait", ":", "unloaded_cores", ".", "add", "(", "p", ")", "if", "len", "(", "unloaded_cores", ")", ">", "0", ":", "unloaded_targets", "[", "(", "x", ",", "y", ")", "]", "=", "unloaded_cores", "if", "len", "(", "unloaded_targets", ")", ">", "0", ":", "new_unloadeds", "[", "app_name", "]", "=", "unloaded_targets", "unloaded", "=", "new_unloadeds", "# If there are still unloaded cores then we bail", "if", "unloaded", "!=", "{", "}", ":", "raise", "SpiNNakerLoadingError", "(", "unloaded", ")", "# If not waiting then send the start signal", "if", "not", "wait", ":", "self", ".", "send_signal", "(", "\"start\"", ",", "app_id", ")" ]

[ "Load", "an", "application", "to", "a", "set", "of", "application", "cores", "." ]

[ "def", "rel2id", "(", "self", ",", "xs", ")", ":", "if", "isinstance", "(", "xs", ",", "list", ")", ":", "return", "[", "self", ".", "_rel2id", "[", "x", "]", "for", "x", "in", "xs", "]", "return", "self", ".", "_rel2id", "[", "xs", "]" ]

[ "Map", "relation", "(", "s", ")", "to", "id", "(", "s", ")" ]

[ "def", "subvolume_list", "(", "path", ",", "parent_id", "=", "False", ",", "absolute", "=", "False", ",", "ogeneration", "=", "False", ",", "generation", "=", "False", ",", "subvolumes", "=", "False", ",", "uuid", "=", "False", ",", "parent_uuid", "=", "False", ",", "sent_subvolume_uuid", "=", "False", ",", "snapshots", "=", "False", ",", "readonly", "=", "False", ",", "deleted", "=", "False", ",", "generation_cmp", "=", "None", ",", "ogeneration_cmp", "=", "None", ",", "sort", "=", "None", ")", ":", "if", "sort", "and", "type", "(", "sort", ")", "is", "not", "list", ":", "raise", "CommandExecutionError", "(", "'Sort parameter must be a list'", ")", "valid_sorts", "=", "[", "''", ".", "join", "(", "(", "order", ",", "attrib", ")", ")", "for", "order", ",", "attrib", "in", "itertools", ".", "product", "(", "(", "'-'", ",", "''", ",", "'+'", ")", ",", "(", "'rootid'", ",", "'gen'", ",", "'ogen'", ",", "'path'", ")", ")", "]", "if", "sort", "and", "not", "all", "(", "s", "in", "valid_sorts", "for", "s", "in", "sort", ")", ":", "raise", "CommandExecutionError", "(", "'Value for sort not recognized'", ")", "cmd", "=", "[", "'btrfs'", ",", "'subvolume'", ",", "'list'", "]", "params", "=", "(", "(", "parent_id", ",", "'-p'", ")", ",", "(", "absolute", ",", "'-a'", ")", ",", "(", "ogeneration", ",", "'-c'", ")", ",", "(", "generation", ",", "'-g'", ")", ",", "(", "subvolumes", ",", "'-o'", ")", ",", "(", "uuid", ",", "'-u'", ")", ",", "(", "parent_uuid", ",", "'-q'", ")", ",", "(", "sent_subvolume_uuid", ",", "'-R'", ")", ",", "(", "snapshots", ",", "'-s'", ")", ",", "(", "readonly", ",", "'-r'", ")", ",", "(", "deleted", ",", "'-d'", ")", ")", "cmd", ".", "extend", "(", "p", "[", "1", "]", "for", "p", "in", "params", "if", "p", "[", "0", "]", ")", "if", "generation_cmp", ":", "cmd", ".", "extend", "(", "[", "'-G'", ",", "generation_cmp", "]", ")", "if", "ogeneration_cmp", ":", "cmd", ".", "extend", "(", "[", "'-C'", ",", "ogeneration_cmp", "]", ")", "# We already validated the content of the list", "if", "sort", ":", "cmd", ".", "append", "(", "'--sort={}'", ".", "format", "(", "','", ".", "join", "(", "sort", ")", ")", ")", "cmd", ".", "append", "(", "path", ")", "res", "=", "__salt__", "[", "'cmd.run_all'", "]", "(", "cmd", ")", "salt", ".", "utils", ".", "fsutils", ".", "_verify_run", "(", "res", ")", "# Parse the output. ID and gen are always at the begining, and", "# path is always at the end. There is only one column that", "# contains space (top level), and the path value can also have", "# spaces. The issue is that we do not know how many spaces do we", "# have in the path name, so any classic solution based on split", "# will fail.", "#", "# This list is in order.", "columns", "=", "(", "'ID'", ",", "'gen'", ",", "'cgen'", ",", "'parent'", ",", "'top level'", ",", "'otime'", ",", "'parent_uuid'", ",", "'received_uuid'", ",", "'uuid'", ",", "'path'", ")", "result", "=", "[", "]", "for", "line", "in", "res", "[", "'stdout'", "]", ".", "splitlines", "(", ")", ":", "table", "=", "{", "}", "for", "key", "in", "columns", ":", "value", ",", "line", "=", "_pop", "(", "line", ",", "key", ",", "key", "==", "'path'", ")", "if", "value", ":", "table", "[", "key", ".", "lower", "(", ")", "]", "=", "value", "# If line is not empty here, we are not able to parse it", "if", "not", "line", ":", "result", ".", "append", "(", "table", ")", "return", "result" ]

[ "List", "the", "subvolumes", "present", "in", "the", "filesystem", "." ]

[ "def", "populate", "(", "self", ",", "priority", ",", "address", ",", "rtr", ",", "data", ")", ":", "assert", "isinstance", "(", "data", ",", "bytes", ")", "self", ".", "needs_no_rtr", "(", "rtr", ")", "self", ".", "needs_data", "(", "data", ",", "7", ")", "self", ".", "set_attributes", "(", "priority", ",", "address", ",", "rtr", ")", "self", ".", "local_control", "=", "(", "data", "[", "0", "]", "&", "0x01", ")", "self", ".", "status_mode", "=", "(", "data", "[", "0", "]", "&", "0x206", ")", "self", ".", "_status_str", "=", "DSTATUS", "[", "self", ".", "status_mode", "]", "self", ".", "auto_send", "=", "(", "data", "[", "0", "]", "&", "0x08", ")", "self", ".", "mode", "=", "(", "data", "[", "0", "]", "&", "0x70", ")", "self", ".", "mode_str", "=", "DMODE", "[", "self", ".", "mode", "]", "self", ".", "cool", "=", "(", "data", "[", "0", "]", "&", "0x80", ")", "self", ".", "heater", "=", "(", "data", "[", "2", "]", "&", "0x01", ")", "self", ".", "boost", "=", "(", "data", "[", "2", "]", "&", "0x02", ")", "self", ".", "pump", "=", "(", "data", "[", "2", "]", "&", "0x04", ")", "self", ".", "cool", "=", "(", "data", "[", "2", "]", "&", "0x08", ")", "self", ".", "alarm1", "=", "(", "data", "[", "2", "]", "&", "0x10", ")", "self", ".", "alarm2", "=", "(", "data", "[", "2", "]", "&", "0x20", ")", "self", ".", "alarm3", "=", "(", "data", "[", "2", "]", "&", "0x40", ")", "self", ".", "alarm4", "=", "(", "data", "[", "2", "]", "&", "0x80", ")", "self", ".", "current_temp", "=", "data", "[", "3", "]", "/", "2", "self", ".", "target_temp", "=", "data", "[", "4", "]", "/", "2", "self", ".", "sleep_timer", "=", "(", "data", "[", "5", "]", "<<", "8", ")", "+", "data", "[", "6", "]" ]

[ "-", "DB1", "last", "bit", "=", "local_control", "-", "DB1", "bit", "2", "+", "3", "=", "status_mode", "-", "DB1", "bit", "4", "=", "auto", "send", "-", "DB1", "bit", "5", "+", "6", "+", "7", "=", "mode", "-", "DB1", "bit", "8", "=", "cool", "-", "DB2", "=", "program", "(", "not", "used", ")", "-", "DB3", "last", "bit", "=", "heater", "-", "DB3", "bit", "2", "=", "boost", "-", "DB3", "bit", "3", "=", "pump", "-", "DB3", "bit", "4", "=", "pump", "-", "DB4", "bit", "5", "=", "alarm", "1", "-", "DB4", "bit", "6", "=", "alarm", "2", "-", "DB4", "bit", "7", "=", "alarm", "3", "-", "DB4", "bit", "8", "=", "alarm", "4", "-", "DB5", "current", "temp", "=", "current", "temp", "-", "DB6", "target", "temp", "=", "target", "temp", "-", "DB7", "-", "8", "sleep", "timer", "=", "0", "=", "off", ">", "0", "=", "x", "min", ":", "return", ":", "None" ]

[ "def", "max_min_l1", "(", "self", ",", "reaction", ",", "weights", "=", "{", "}", ")", ":", "self", ".", "maximize", "(", "reaction", ")", "if", "isinstance", "(", "reaction", ",", "dict", ")", ":", "reactions", "=", "list", "(", "reaction", ")", "else", ":", "reactions", "=", "[", "reaction", "]", "# Save flux values before modifying the LP problem", "fluxes", "=", "{", "r", ":", "self", ".", "get_flux", "(", "r", ")", "for", "r", "in", "reactions", "}", "# Add constraints on the maximized reactions", "for", "r", "in", "reactions", ":", "flux_var", "=", "self", ".", "get_flux_var", "(", "r", ")", "c", ",", "=", "self", ".", "_prob", ".", "add_linear_constraints", "(", "flux_var", "==", "fluxes", "[", "r", "]", ")", "self", ".", "_temp_constr", ".", "append", "(", "c", ")", "self", ".", "minimize_l1", "(", "weights", ")" ]

[ "Maximize", "flux", "of", "reaction", "then", "minimize", "the", "L1", "norm", "." ]

[ "def", "recognise_model", "(", "feature_filename", ",", "symbollist_filename", ",", "model_directory", ",", "recognition_filename", ",", "pronunciation_dictionary_filename", ",", "list_words_filename", "=", "''", ",", "cmllr_directory", "=", "None", ",", "tokens_count", "=", "None", ",", "hypotheses_count", "=", "1", ",", "htk_trace", "=", "0", ")", ":", "# Normalize UTF-8 to avoid Mac problems", "temp_dictionary_filename", "=", "utf8_normalize", "(", "pronunciation_dictionary_filename", ")", "# Create language word list", "if", "list_words_filename", ":", "list_words", "=", "parse_wordlist", "(", "list_words_filename", ")", "else", ":", "list_words", "=", "sorted", "(", "parse_dictionary", "(", "temp_dictionary_filename", ")", ".", "keys", "(", ")", ")", "# Create language model", "temp_directory", "=", "config", ".", "project_path", "(", "'tmp'", ",", "create", "=", "True", ")", "grammar_filename", "=", "config", ".", "path", "(", "temp_directory", ",", "'grammar_words'", ")", "wdnet_filename", "=", "config", ".", "path", "(", "temp_directory", ",", "'wdnet'", ")", "logging", ".", "debug", "(", "'Create language model'", ")", "create_language_model", "(", "list_words", ",", "grammar_filename", ",", "wdnet_filename", ")", "# Handle the Adaptation parameters", "cmllr_arguments", "=", "''", "if", "cmllr_directory", ":", "if", "not", "os", ".", "path", ".", "isdir", "(", "cmllr_directory", ")", ":", "logging", ".", "error", "(", "'CMLLR adapatation directory not found: {}'", ".", "format", "(", "cmllr_directory", ")", ")", "cmllr_arguments", "=", "\"-J {} mllr2 -h '*/*_s%.mfc' -k -J {}\"", ".", "format", "(", "os", ".", "path", ".", "abspath", "(", "config", ".", "path", "(", "cmllr_directory", ",", "'xforms'", ")", ")", ",", "os", ".", "path", ".", "abspath", "(", "config", ".", "path", "(", "cmllr_directory", ",", "'classes'", ")", ")", ")", "# Handle the N-Best parameters", "hypotheses_count", "=", "hypotheses_count", "or", "1", "tokens_count", "=", "tokens_count", "or", "int", "(", "math", ".", "ceil", "(", "hypotheses_count", "/", "5.0", ")", ")", "if", "hypotheses_count", "==", "1", "and", "tokens_count", "==", "1", ":", "nbest_arguments", "=", "\"\"", "else", ":", "nbest_arguments", "=", "\"-n {tokens_count} {hypotheses_count} \"", ".", "format", "(", "tokens_count", "=", "tokens_count", ",", "hypotheses_count", "=", "hypotheses_count", ")", "# Run the HTK command", "config", ".", "htk_command", "(", "\"HVite -A -l '*' -T {htk_trace} \"", "\"-H {model_directory}/macros -H {model_directory}/hmmdefs \"", "\"-i {recognition_filename} -S {feature_filename} \"", "\"{cmllr_arguments} -w {wdnet_filename} \"", "\"{nbest_arguments} \"", "\"-p 0.0 -s 5.0 \"", "\"{pronunciation_dictionary_filename} \"", "\"{symbollist_filename}\"", ".", "format", "(", "htk_trace", "=", "htk_trace", ",", "model_directory", "=", "model_directory", ",", "recognition_filename", "=", "recognition_filename", ",", "feature_filename", "=", "feature_filename", ",", "symbollist_filename", "=", "symbollist_filename", ",", "nbest_arguments", "=", "nbest_arguments", ",", "pronunciation_dictionary_filename", "=", "temp_dictionary_filename", ",", "wdnet_filename", "=", "wdnet_filename", ",", "cmllr_arguments", "=", "cmllr_arguments", ")", ")", "# Remove temporary files", "os", ".", "remove", "(", "temp_dictionary_filename", ")", "os", ".", "remove", "(", "wdnet_filename", ")", "os", ".", "remove", "(", "grammar_filename", ")" ]

[ "Perform", "recognition", "using", "a", "model", "and", "assuming", "a", "single", "word", "language", "." ]