Datasets:

---

kejian

/

codesearchnet-python-raw

like 1

[ "def", "order_target_percent", "(", "self", ",", "asset", ",", "target", ",", "limit_price", "=", "None", ",", "stop_price", "=", "None", ",", "style", "=", "None", ")", ":", "if", "not", "self", ".", "_can_order_asset", "(", "asset", ")", ":", "return", "None", "amount", "=", "self", ".", "_calculate_order_target_percent_amount", "(", "asset", ",", "target", ")", "return", "self", ".", "order", "(", "asset", ",", "amount", ",", "limit_price", "=", "limit_price", ",", "stop_price", "=", "stop_price", ",", "style", "=", "style", ")" ]

[ "Place", "an", "order", "to", "adjust", "a", "position", "to", "a", "target", "percent", "of", "the", "current", "portfolio", "value", ".", "If", "the", "position", "doesn", "t", "already", "exist", "this", "is", "equivalent", "to", "placing", "a", "new", "order", ".", "If", "the", "position", "does", "exist", "this", "is", "equivalent", "to", "placing", "an", "order", "for", "the", "difference", "between", "the", "target", "percent", "and", "the", "current", "percent", "." ]

[ "def", "get", "(", "cls", ",", "tag_id_or_URI", ",", "label", "=", "None", ")", ":", "# First try to get the tag by ID.", "semantictag", "=", "SemanticTag", ".", "by_id", "(", "tag_id_or_URI", ")", "if", "semantictag", ":", "return", "semantictag", "else", ":", "semantictag", "=", "SemanticTag", ".", "by_URI", "(", "tag_id_or_URI", ")", "return", "semantictag" ]

[ "Return", "the", "tag", "with", "the", "given", "id", "or", "URI", "or", "None", "." ]

[ "def", "plot_median_freq_evol", "(", "time_signal", ",", "signal", ",", "time_median_freq", ",", "median_freq", ",", "activations_begin", ",", "activations_end", ",", "sample_rate", ",", "file_name", "=", "None", ")", ":", "# Generation of the HTML file where the plot will be stored.", "#file_name = _generate_bokeh_file(file_name)", "list_figures_1", "=", "plot", "(", "[", "list", "(", "time_signal", ")", ",", "list", "(", "time_median_freq", ")", "]", ",", "[", "list", "(", "signal", ")", ",", "list", "(", "median_freq", ")", "]", ",", "title", "=", "[", "\"EMG Acquisition highlighting muscular activations\"", ",", "\"Median Frequency Evolution\"", "]", ",", "grid_plot", "=", "True", ",", "grid_lines", "=", "2", ",", "grid_columns", "=", "1", ",", "open_signals_style", "=", "True", ",", "x_axis_label", "=", "\"Time (s)\"", ",", "yAxisLabel", "=", "[", "\"Raw Data\"", ",", "\"Median Frequency (Hz)\"", "]", ",", "x_range", "=", "[", "0", ",", "125", "]", ",", "get_fig_list", "=", "True", ",", "show_plot", "=", "False", ")", "# Highlighting of each processing window", "for", "activation", "in", "range", "(", "0", ",", "len", "(", "activations_begin", ")", ")", ":", "color", "=", "opensignals_color_pallet", "(", ")", "box_annotation", "=", "BoxAnnotation", "(", "left", "=", "activations_begin", "[", "activation", "]", "/", "sample_rate", ",", "right", "=", "activations_end", "[", "activation", "]", "/", "sample_rate", ",", "fill_color", "=", "color", ",", "fill_alpha", "=", "0.1", ")", "box_annotation_copy", "=", "BoxAnnotation", "(", "left", "=", "activations_begin", "[", "activation", "]", "/", "sample_rate", ",", "right", "=", "activations_end", "[", "activation", "]", "/", "sample_rate", ",", "fill_color", "=", "color", ",", "fill_alpha", "=", "0.1", ")", "list_figures_1", "[", "0", "]", ".", "add_layout", "(", "box_annotation", ")", "list_figures_1", "[", "1", "]", ".", "add_layout", "(", "box_annotation_copy", ")", "gridplot_1", "=", "gridplot", "(", "[", "[", "list_figures_1", "[", "0", "]", "]", ",", "[", "list_figures_1", "[", "1", "]", "]", "]", ",", "*", "*", "opensignals_kwargs", "(", "\"gridplot\"", ")", ")", "show", "(", "gridplot_1", ")" ]

[ "-----", "Brief", "-----", "Graphical", "representation", "of", "the", "EMG", "median", "power", "frequency", "evolution", "time", "series", "." ]

[ "def", "index", "(", "args", ")", ":", "p", "=", "OptionParser", "(", "index", ".", "__doc__", ")", "opts", ",", "args", "=", "p", ".", "parse_args", "(", "args", ")", "if", "len", "(", "args", ")", "!=", "1", ":", "sys", ".", "exit", "(", "p", ".", "print_help", "(", ")", ")", "frgscffile", ",", "=", "args", "gzfile", "=", "frgscffile", "+", "\".gz\"", "cmd", "=", "\"bgzip -c {0}\"", ".", "format", "(", "frgscffile", ")", "if", "not", "op", ".", "exists", "(", "gzfile", ")", ":", "sh", "(", "cmd", ",", "outfile", "=", "gzfile", ")", "tbifile", "=", "gzfile", "+", "\".tbi\"", "# Sequence, begin, end in 2, 3, 4-th column, respectively", "cmd", "=", "\"tabix -s 2 -b 3 -e 4 {0}\"", ".", "format", "(", "gzfile", ")", "if", "not", "op", ".", "exists", "(", "tbifile", ")", ":", "sh", "(", "cmd", ")" ]

[ "%prog", "index", "frgscf", ".", "sorted" ]

[ "def", "post", "(", "self", ",", "client_method", ",", "data", ",", "post_params", "=", "None", ",", "is_json", "=", "True", ")", ":", "url", "=", "self", ".", "_wa", ".", "apollo_url", "+", "self", ".", "CLIENT_BASE", "+", "client_method", "if", "post_params", "is", "None", ":", "post_params", "=", "{", "}", "headers", "=", "{", "'Content-Type'", ":", "'application/json'", "}", "data", ".", "update", "(", "{", "'username'", ":", "self", ".", "_wa", ".", "username", ",", "'password'", ":", "self", ".", "_wa", ".", "password", ",", "}", ")", "curl_command", "=", "[", "'curl'", ",", "url", "]", "for", "(", "k", ",", "v", ")", "in", "headers", ".", "items", "(", ")", ":", "curl_command", "+=", "[", "'-H'", ",", "quote", "(", "'%s: %s'", "%", "(", "k", ",", "v", ")", ")", "]", "curl_command", "+=", "[", "'-d'", ",", "quote", "(", "json", ".", "dumps", "(", "data", ")", ")", "]", "log", ".", "info", "(", "' '", ".", "join", "(", "curl_command", ")", ")", "resp", "=", "requests", ".", "post", "(", "url", ",", "data", "=", "json", ".", "dumps", "(", "data", ")", ",", "headers", "=", "headers", ",", "verify", "=", "self", ".", "__verify", ",", "params", "=", "post_params", ",", "allow_redirects", "=", "False", ",", "*", "*", "self", ".", "_request_args", ")", "if", "resp", ".", "status_code", "==", "200", "or", "resp", ".", "status_code", "==", "302", ":", "if", "is_json", ":", "data", "=", "resp", ".", "json", "(", ")", "return", "self", ".", "_scrub_data", "(", "data", ")", "else", ":", "return", "resp", ".", "text", "# @see self.body for HTTP response body", "raise", "Exception", "(", "\"Unexpected response from apollo %s: %s\"", "%", "(", "resp", ".", "status_code", ",", "resp", ".", "text", ")", ")" ]

[ "Make", "a", "POST", "request" ]

[ "def", "getbit", "(", "self", ",", "name", ",", "offset", ")", ":", "with", "self", ".", "pipe", "as", "pipe", ":", "return", "pipe", ".", "getbit", "(", "self", ".", "redis_key", "(", "name", ")", ",", "offset", ")" ]

[ "Returns", "a", "boolean", "indicating", "the", "value", "of", "offset", "in", "key" ]

[ "def", "unify", "(", "self", ",", "result", ")", ":", "if", "isinstance", "(", "result", ".", "get", "(", "'comment'", ")", ",", "list", ")", ":", "result", "[", "'comment'", "]", "=", "u'\\n'", ".", "join", "(", "[", "salt", ".", "utils", ".", "stringutils", ".", "to_unicode", "(", "elm", ")", "for", "elm", "in", "result", "[", "'comment'", "]", "]", ")", "if", "result", ".", "get", "(", "'result'", ")", "is", "not", "None", ":", "result", "[", "'result'", "]", "=", "bool", "(", "result", "[", "'result'", "]", ")", "return", "result" ]

[ "While", "comments", "as", "a", "list", "are", "allowed", "comments", "needs", "to", "be", "strings", "for", "backward", "compatibility", ".", "See", "such", "claim", "here", ":", "https", ":", "//", "github", ".", "com", "/", "saltstack", "/", "salt", "/", "pull", "/", "43070" ]

[ "def", "decode_string", "(", "s", ")", ":", "stack", "=", "[", "]", "cur_num", "=", "0", "cur_string", "=", "''", "for", "c", "in", "s", ":", "if", "c", "==", "'['", ":", "stack", ".", "append", "(", "(", "cur_string", ",", "cur_num", ")", ")", "cur_string", "=", "''", "cur_num", "=", "0", "elif", "c", "==", "']'", ":", "prev_string", ",", "num", "=", "stack", ".", "pop", "(", ")", "cur_string", "=", "prev_string", "+", "num", "*", "cur_string", "elif", "c", ".", "isdigit", "(", ")", ":", "cur_num", "=", "cur_num", "*", "10", "+", "int", "(", "c", ")", "else", ":", "cur_string", "+=", "c", "return", "cur_string" ]

[ ":", "type", "s", ":", "str", ":", "rtype", ":", "str" ]

[ "def", "get_num_features", "(", "estimator", ")", ":", "if", "hasattr", "(", "estimator", ",", "'coef_'", ")", ":", "# linear models", "if", "len", "(", "estimator", ".", "coef_", ".", "shape", ")", "==", "0", ":", "return", "1", "return", "estimator", ".", "coef_", ".", "shape", "[", "-", "1", "]", "elif", "hasattr", "(", "estimator", ",", "'feature_importances_'", ")", ":", "# ensembles", "return", "estimator", ".", "feature_importances_", ".", "shape", "[", "-", "1", "]", "elif", "hasattr", "(", "estimator", ",", "'feature_count_'", ")", ":", "# naive bayes", "return", "estimator", ".", "feature_count_", ".", "shape", "[", "-", "1", "]", "elif", "hasattr", "(", "estimator", ",", "'theta_'", ")", ":", "return", "estimator", ".", "theta_", ".", "shape", "[", "-", "1", "]", "elif", "hasattr", "(", "estimator", ",", "'estimators_'", ")", "and", "len", "(", "estimator", ".", "estimators_", ")", ":", "# OvR", "return", "get_num_features", "(", "estimator", ".", "estimators_", "[", "0", "]", ")", "else", ":", "raise", "ValueError", "(", "\"Can't figure out feature vector size for %s\"", "%", "estimator", ")" ]

[ "Return", "size", "of", "a", "feature", "vector", "estimator", "expects", "as", "an", "input", "." ]

[ "def", "space", "(", "self", ")", ":", "schema", "=", "SpaceSchema", "(", ")", "resp", "=", "self", ".", "service", ".", "get", "(", "self", ".", "base", "+", "'space/'", ")", "return", "self", ".", "service", ".", "decode", "(", "schema", ",", "resp", ")" ]

[ "Get", "system", "disk", "space", "usage", "." ]

[ "def", "locate_key", "(", "self", ",", "key", ")", ":", "left", "=", "bisect", ".", "bisect_left", "(", "self", ",", "key", ")", "right", "=", "bisect", ".", "bisect_right", "(", "self", ",", "key", ")", "diff", "=", "right", "-", "left", "if", "diff", "==", "0", ":", "raise", "KeyError", "(", "key", ")", "elif", "diff", "==", "1", ":", "return", "left", "else", ":", "return", "slice", "(", "left", ",", "right", ")" ]

[ "Get", "index", "location", "for", "the", "requested", "key", "." ]

[ "def", "run", "(", "self", ",", "dag", ")", ":", "num_dag_qubits", "=", "sum", "(", "[", "qreg", ".", "size", "for", "qreg", "in", "dag", ".", "qregs", ".", "values", "(", ")", "]", ")", "if", "num_dag_qubits", ">", "self", ".", "coupling_map", ".", "size", "(", ")", ":", "raise", "TranspilerError", "(", "'Number of qubits greater than device.'", ")", "best_sub", "=", "self", ".", "_best_subset", "(", "num_dag_qubits", ")", "layout", "=", "Layout", "(", ")", "map_iter", "=", "0", "for", "qreg", "in", "dag", ".", "qregs", ".", "values", "(", ")", ":", "for", "i", "in", "range", "(", "qreg", ".", "size", ")", ":", "layout", "[", "(", "qreg", ",", "i", ")", "]", "=", "int", "(", "best_sub", "[", "map_iter", "]", ")", "map_iter", "+=", "1", "self", ".", "property_set", "[", "'layout'", "]", "=", "layout" ]

[ "Pick", "a", "convenient", "layout", "depending", "on", "the", "best", "matching", "qubit", "connectivity", "and", "set", "the", "property", "layout", "." ]

[ "def", "get", "(", "cls", ",", "name", ":", "sym", ".", "Symbol", ")", "->", "\"Optional[Namespace]\"", ":", "return", "cls", ".", "_NAMESPACES", ".", "deref", "(", ")", ".", "entry", "(", "name", ",", "None", ")" ]

[ "Get", "the", "namespace", "bound", "to", "the", "symbol", "name", "in", "the", "global", "namespace", "cache", ".", "Return", "the", "namespace", "if", "it", "exists", "or", "None", "otherwise", ".." ]

[ "def", "triplifyOverallStructures", "(", "self", ")", ":", "if", "self", ".", "compute_networks", ":", "self", ".", "computeNetworks", "(", ")", "if", "self", ".", "compute_bows", ":", "self", ".", "computeBows", "(", ")" ]

[ "Insert", "into", "RDF", "graph", "the", "textual", "and", "network", "structures", "." ]

[ "def", "_cache_init", "(", "self", ")", ":", "cache_", "=", "cache", ".", "get", "(", "self", ".", "CACHE_ENTRY_NAME", ")", "if", "cache_", "is", "None", ":", "categories", "=", "get_category_model", "(", ")", ".", "objects", ".", "order_by", "(", "'sort_order'", ")", "ids", "=", "{", "category", ".", "id", ":", "category", "for", "category", "in", "categories", "}", "aliases", "=", "{", "category", ".", "alias", ":", "category", "for", "category", "in", "categories", "if", "category", ".", "alias", "}", "parent_to_children", "=", "OrderedDict", "(", ")", "# Preserve aliases order.", "for", "category", "in", "categories", ":", "parent_category", "=", "ids", ".", "get", "(", "category", ".", "parent_id", ",", "False", ")", "parent_alias", "=", "None", "if", "parent_category", ":", "parent_alias", "=", "parent_category", ".", "alias", "if", "parent_alias", "not", "in", "parent_to_children", ":", "parent_to_children", "[", "parent_alias", "]", "=", "[", "]", "parent_to_children", "[", "parent_alias", "]", ".", "append", "(", "category", ".", "id", ")", "cache_", "=", "{", "self", ".", "CACHE_NAME_IDS", ":", "ids", ",", "self", ".", "CACHE_NAME_PARENTS", ":", "parent_to_children", ",", "self", ".", "CACHE_NAME_ALIASES", ":", "aliases", "}", "cache", ".", "set", "(", "self", ".", "CACHE_ENTRY_NAME", ",", "cache_", ",", "self", ".", "CACHE_TIMEOUT", ")", "self", ".", "_cache", "=", "cache_" ]

[ "Initializes", "local", "cache", "from", "Django", "cache", "if", "required", "." ]

[ "def", "_read_checkplot_picklefile", "(", "checkplotpickle", ")", ":", "if", "checkplotpickle", ".", "endswith", "(", "'.gz'", ")", ":", "try", ":", "with", "gzip", ".", "open", "(", "checkplotpickle", ",", "'rb'", ")", "as", "infd", ":", "cpdict", "=", "pickle", ".", "load", "(", "infd", ")", "except", "UnicodeDecodeError", ":", "with", "gzip", ".", "open", "(", "checkplotpickle", ",", "'rb'", ")", "as", "infd", ":", "cpdict", "=", "pickle", ".", "load", "(", "infd", ",", "encoding", "=", "'latin1'", ")", "else", ":", "try", ":", "with", "open", "(", "checkplotpickle", ",", "'rb'", ")", "as", "infd", ":", "cpdict", "=", "pickle", ".", "load", "(", "infd", ")", "except", "UnicodeDecodeError", ":", "with", "open", "(", "checkplotpickle", ",", "'rb'", ")", "as", "infd", ":", "cpdict", "=", "pickle", ".", "load", "(", "infd", ",", "encoding", "=", "'latin1'", ")", "return", "cpdict" ]

[ "This", "reads", "a", "checkplot", "gzipped", "pickle", "file", "back", "into", "a", "dict", "." ]

[ "def", "save", "(", "self", ",", "fname", ")", ":", "try", ":", "with", "open", "(", "fname", ",", "\"w\"", ")", "as", "f", ":", "f", ".", "write", "(", "str", "(", "self", ")", ")", "except", "Exception", "as", "ex", ":", "print", "(", "'ERROR = cant save grid results to '", "+", "fname", "+", "str", "(", "ex", ")", ")" ]

[ "saves", "a", "grid", "to", "file", "as", "ASCII", "text" ]

[ "def", "_mutual_info_score", "(", "reference_indices", ",", "estimated_indices", ",", "contingency", "=", "None", ")", ":", "if", "contingency", "is", "None", ":", "contingency", "=", "_contingency_matrix", "(", "reference_indices", ",", "estimated_indices", ")", ".", "astype", "(", "float", ")", "contingency_sum", "=", "np", ".", "sum", "(", "contingency", ")", "pi", "=", "np", ".", "sum", "(", "contingency", ",", "axis", "=", "1", ")", "pj", "=", "np", ".", "sum", "(", "contingency", ",", "axis", "=", "0", ")", "outer", "=", "np", ".", "outer", "(", "pi", ",", "pj", ")", "nnz", "=", "contingency", "!=", "0.0", "# normalized contingency", "contingency_nm", "=", "contingency", "[", "nnz", "]", "log_contingency_nm", "=", "np", ".", "log", "(", "contingency_nm", ")", "contingency_nm", "/=", "contingency_sum", "# log(a / b) should be calculated as log(a) - log(b) for", "# possible loss of precision", "log_outer", "=", "-", "np", ".", "log", "(", "outer", "[", "nnz", "]", ")", "+", "np", ".", "log", "(", "pi", ".", "sum", "(", ")", ")", "+", "np", ".", "log", "(", "pj", ".", "sum", "(", ")", ")", "mi", "=", "(", "contingency_nm", "*", "(", "log_contingency_nm", "-", "np", ".", "log", "(", "contingency_sum", ")", ")", "+", "contingency_nm", "*", "log_outer", ")", "return", "mi", ".", "sum", "(", ")" ]

[ "Compute", "the", "mutual", "information", "between", "two", "sequence", "labelings", "." ]

[ "def", "_discover", "(", "self", ")", ":", "for", "ep", "in", "pkg_resources", ".", "iter_entry_points", "(", "'yamlsettings10'", ")", ":", "ext", "=", "ep", ".", "load", "(", ")", "if", "callable", "(", "ext", ")", ":", "ext", "=", "ext", "(", ")", "self", ".", "add", "(", "ext", ")" ]

[ "Find", "and", "install", "all", "extensions" ]

[ "def", "module_remove", "(", "name", ")", ":", "ret", "=", "{", "'name'", ":", "name", ",", "'result'", ":", "True", ",", "'comment'", ":", "''", ",", "'changes'", ":", "{", "}", "}", "modules", "=", "__salt__", "[", "'selinux.list_semod'", "]", "(", ")", "if", "name", "not", "in", "modules", ":", "ret", "[", "'comment'", "]", "=", "'Module {0} is not available'", ".", "format", "(", "name", ")", "ret", "[", "'result'", "]", "=", "False", "return", "ret", "if", "__salt__", "[", "'selinux.remove_semod'", "]", "(", "name", ")", ":", "ret", "[", "'comment'", "]", "=", "'Module {0} has been removed'", ".", "format", "(", "name", ")", "return", "ret", "ret", "[", "'result'", "]", "=", "False", "ret", "[", "'comment'", "]", "=", "'Failed to remove module {0}'", ".", "format", "(", "name", ")", "return", "ret" ]

[ "Removes", "SELinux", "module" ]

[ "def", "imag", "(", "self", ",", "newimag", ")", ":", "if", "self", ".", "space", ".", "is_real", ":", "raise", "ValueError", "(", "'cannot set imaginary part in real spaces'", ")", "self", ".", "tensor", ".", "imag", "=", "newimag" ]

[ "Set", "the", "imaginary", "part", "of", "this", "element", "to", "newimag", "." ]

[ "def", "stage_tc_create_tag", "(", "self", ",", "tag", ",", "resource", ")", ":", "tag_resource", "=", "resource", ".", "tags", "(", "self", ".", "tcex", ".", "safetag", "(", "tag", ")", ")", "tag_resource", ".", "http_method", "=", "'POST'", "t_response", "=", "tag_resource", ".", "request", "(", ")", "if", "t_response", ".", "get", "(", "'status'", ")", "!=", "'Success'", ":", "self", ".", "log", ".", "warning", "(", "'[tcex] Failed adding tag \"{}\" ({}).'", ".", "format", "(", "tag", ",", "t_response", ".", "get", "(", "'response'", ")", ".", "text", ")", ")" ]

[ "Add", "a", "tag", "to", "a", "resource", "." ]

[ "def", "from_payload", "(", "self", ",", "payload", ")", ":", "self", ".", "_software_version", "=", "payload", "[", "0", ":", "6", "]", "self", ".", "hardware_version", "=", "payload", "[", "6", "]", "self", ".", "product_group", "=", "payload", "[", "7", "]", "self", ".", "product_type", "=", "payload", "[", "8", "]" ]

[ "Init", "frame", "from", "binary", "data", "." ]

[ "def", "set_hint_style", "(", "self", ",", "hint_style", ")", ":", "cairo", ".", "cairo_font_options_set_hint_style", "(", "self", ".", "_pointer", ",", "hint_style", ")", "self", ".", "_check_status", "(", ")" ]

[ "Changes", "the", ":", "ref", ":", "HINT_STYLE", "for", "the", "font", "options", "object", ".", "This", "controls", "whether", "to", "fit", "font", "outlines", "to", "the", "pixel", "grid", "and", "if", "so", "whether", "to", "optimize", "for", "fidelity", "or", "contrast", "." ]

[ "def", "addSubEditor", "(", "self", ",", "subEditor", ",", "isFocusProxy", "=", "False", ")", ":", "self", ".", "hBoxLayout", ".", "insertWidget", "(", "len", "(", "self", ".", "_subEditors", ")", ",", "subEditor", ")", "self", ".", "_subEditors", ".", "append", "(", "subEditor", ")", "subEditor", ".", "installEventFilter", "(", "self", ")", "subEditor", ".", "setFocusPolicy", "(", "Qt", ".", "StrongFocus", ")", "if", "isFocusProxy", ":", "self", ".", "setFocusProxy", "(", "subEditor", ")", "return", "subEditor" ]

[ "Adds", "a", "sub", "editor", "to", "the", "layout", "(", "at", "the", "right", "but", "before", "the", "reset", "button", ")", "Will", "add", "the", "necessary", "event", "filter", "to", "handle", "tabs", "and", "sets", "the", "strong", "focus", "so", "that", "events", "will", "not", "propagate", "to", "the", "tree", "view", "." ]

[ "def", "items", "(", "self", ")", ":", "query", "=", "self", ".", "get_queryset", "(", ")", "fields", "=", "self", ".", "get_model_config", "(", ")", ".", "get_list_fields", "(", ")", "for", "item", "in", "query", ".", "iterator", "(", ")", ":", "row", "=", "OrderedDict", "(", ")", "for", "field_name", "in", "self", ".", "get_current_fields", "(", ")", ":", "field", "=", "fields", ".", "get", "(", "field_name", ")", "if", "not", "field_name", ":", "row", "[", "field_name", "]", "=", "''", "if", "hasattr", "(", "item", ",", "field", "[", "'field'", "]", ")", ":", "row", "[", "field_name", "]", "=", "getattr", "(", "item", ",", "field", "[", "'field'", "]", ")", "else", ":", "row", "[", "field_name", "]", "=", "''", "# TODO Maybe render field ans strip html?", "yield", "row" ]

[ "Get", "all", "list", "items" ]

[ "def", "edges", "(", "self", ")", ":", "canonical_edges", "=", "set", "(", ")", "for", "v1", ",", "neighbours", "in", "self", ".", "_vertices", ".", "items", "(", ")", ":", "for", "v2", "in", "neighbours", ":", "edge", "=", "self", ".", "canonical_order", "(", "(", "v1", ",", "v2", ")", ")", "canonical_edges", ".", "add", "(", "edge", ")", "return", "canonical_edges" ]

[ "Edges", "of", "this", "graph", "in", "canonical", "order", "." ]

[ "def", "_can_be_double", "(", "x", ")", ":", "return", "(", "(", "np", ".", "issubdtype", "(", "x", ".", "dtype", ",", "np", ".", "floating", ")", "and", "x", ".", "dtype", ".", "itemsize", "<=", "np", ".", "dtype", "(", "float", ")", ".", "itemsize", ")", "or", "(", "np", ".", "issubdtype", "(", "x", ".", "dtype", ",", "np", ".", "signedinteger", ")", "and", "np", ".", "can_cast", "(", "x", ",", "float", ")", ")", ")" ]

[ "Return", "if", "the", "array", "can", "be", "safely", "converted", "to", "double", "." ]

[ "def", "set_content", "(", "self", ",", "content", ")", ":", "cursor", "=", "self", ".", "textCursor", "(", ")", "cursor", ".", "movePosition", "(", "QTextCursor", ".", "Start", ",", "QTextCursor", ".", "MoveAnchor", ")", "cursor", ".", "movePosition", "(", "QTextCursor", ".", "End", ",", "QTextCursor", ".", "KeepAnchor", ")", "cursor", ".", "removeSelectedText", "(", ")", "for", "line", "in", "content", ":", "self", ".", "moveCursor", "(", "QTextCursor", ".", "End", ")", "self", ".", "insertPlainText", "(", "line", ")", "return", "True" ]

[ "Sets", "document", "with", "given", "content", "while", "providing", "undo", "capability", "." ]

[ "def", "setContentLen", "(", "self", ",", "content", ",", "len", ")", ":", "libxml2mod", ".", "xmlNodeSetContentLen", "(", "self", ".", "_o", ",", "content", ",", "len", ")" ]

[ "Replace", "the", "content", "of", "a", "node", ".", "NOTE", ":" ]

[ "def", "decimate_rms", "(", "self", ",", "a", ",", "maxpoints", ",", "*", "*", "kwargs", ")", ":", "return", "self", ".", "_decimate", "(", "numkit", ".", "timeseries", ".", "rms_histogrammed_function", ",", "a", ",", "maxpoints", ",", "*", "*", "kwargs", ")" ]

[ "Return", "data", "*", "a", "*", "rms", "-", "decimated", "on", "*", "maxpoints", "*", "." ]

[ "def", "is_duplicate_content_url", "(", "url1", ",", "url2", ")", ":", "if", "url1", "==", "url2", ":", "return", "True", "if", "url2", "in", "url1", ":", "url1", "=", "shorten_duplicate_content_url", "(", "url1", ")", "if", "not", "url2", ".", "endswith", "(", "'/'", ")", "and", "url1", ".", "endswith", "(", "'/'", ")", ":", "url2", "+=", "'/'", "return", "url1", "==", "url2", "if", "url1", "in", "url2", ":", "url2", "=", "shorten_duplicate_content_url", "(", "url2", ")", "if", "not", "url1", ".", "endswith", "(", "'/'", ")", "and", "url2", ".", "endswith", "(", "'/'", ")", ":", "url1", "+=", "'/'", "return", "url1", "==", "url2", "return", "False" ]

[ "Check", "if", "both", "URLs", "are", "allowed", "to", "point", "to", "the", "same", "content", "." ]

[ "def", "get_tile_url", "(", "self", ",", "x", ",", "y", ",", "z", ",", "layer_id", "=", "None", ",", "feature_id", "=", "None", ",", "filter", "=", "None", ",", "extension", "=", "\"png\"", ")", ":", "base_url", "=", "self", ".", "client", ".", "base_url", "+", "self", ".", "Meta", ".", "collection_endpoint", "template_id", "=", "self", ".", "template_id", "if", "hasattr", "(", "self", ",", "'template_id'", ")", "else", "self", ".", "layergroupid", "if", "layer_id", "is", "not", "None", "and", "feature_id", "is", "not", "None", ":", "url", "=", "urljoin", "(", "base_url", ",", "\"{template_id}/{layer}/attributes/{feature_id}\"", ")", ".", "format", "(", "template_id", "=", "template_id", ",", "layer", "=", "layer_id", ",", "feature_id", "=", "feature_id", ")", "elif", "layer_id", "is", "not", "None", "and", "filter", "is", "not", "None", ":", "url", "=", "urljoin", "(", "base_url", ",", "\"{template_id}/{filter}/{z}/{x}/{y}.{extension}\"", ")", ".", "format", "(", "template_id", "=", "template_id", ",", "filter", "=", "filter", ",", "z", "=", "z", ",", "x", "=", "x", ",", "y", "=", "y", ",", "extension", "=", "extension", ")", "elif", "layer_id", "is", "not", "None", ":", "url", "=", "urljoin", "(", "base_url", ",", "\"{template_id}/{layer}/{z}/{x}/{y}.{extension}\"", ")", ".", "format", "(", "template_id", "=", "template_id", ",", "layer", "=", "layer_id", ",", "z", "=", "z", ",", "x", "=", "x", ",", "y", "=", "y", ",", "extension", "=", "extension", ")", "else", ":", "url", "=", "urljoin", "(", "base_url", ",", "\"{template_id}/{z}/{x}/{y}.{extension}\"", ")", ".", "format", "(", "template_id", "=", "template_id", ",", "z", "=", "z", ",", "x", "=", "x", ",", "y", "=", "y", ",", "extension", "=", "extension", ")", "if", "hasattr", "(", "self", ",", "'auth'", ")", "and", "self", ".", "auth", "is", "not", "None", "and", "len", "(", "self", ".", "auth", "[", "'valid_tokens'", "]", ")", ">", "0", ":", "url", "=", "urljoin", "(", "url", ",", "\"?auth_token={auth_token}\"", ")", ".", "format", "(", "auth_token", "=", "self", ".", "auth", "[", "'valid_tokens'", "]", "[", "0", "]", ")", "return", "url" ]

[ "Prepares", "a", "URL", "to", "get", "data", "(", "raster", "or", "vector", ")", "from", "a", "NamedMap", "or", "AnonymousMap" ]

[ "def", "filter_by_name_or_id_or_tag", "(", "self", ",", "query_string", ",", "queryset", "=", "None", ")", ":", "assert", "self", ".", "Model", ".", "NAME_FIELD", ",", "'NAME_FIELD is missing on model %s'", "%", "self", ".", "Model", ".", "__name__", "assert", "self", ".", "Model", ".", "ID_FIELD", ",", "'ID_FIELD is missing on model %s'", "%", "self", ".", "Model", ".", "__name__", "assert", "self", ".", "Model", ".", "TAG_FIELD", ",", "'TAG_FIELD is missing on model %s'", "%", "self", ".", "Model", ".", "__name__", "filter_args", "=", "{", "}", "name", ",", "uuid", ",", "tag", "=", "self", ".", "_parse_as_name_or_id_or_tag", "(", "query_string", ")", "if", "name", "is", "not", "None", ":", "filter_args", "[", "self", ".", "Model", ".", "NAME_FIELD", "]", "=", "name", "if", "uuid", "is", "not", "None", ":", "filter_args", "[", "self", ".", "Model", ".", "ID_FIELD", "+", "'__startswith'", "]", "=", "uuid", "if", "tag", "is", "not", "None", ":", "filter_args", "[", "self", ".", "Model", ".", "TAG_FIELD", "]", "=", "tag", "if", "queryset", "is", "None", ":", "queryset", "=", "self", ".", "Model", ".", "objects", ".", "all", "(", ")", "return", "queryset", ".", "filter", "(", "*", "*", "filter_args", ")" ]

[ "Find", "objects", "that", "match", "the", "identifier", "of", "form", "{", "name", "}" ]

[ "def", "sum_to_n", "(", "n", ",", "size", ",", "limit", "=", "None", ")", ":", "#from http://stackoverflow.com/questions/2065553/python-get-all-numbers-that-add-up-to-a-number", "if", "size", "==", "1", ":", "yield", "[", "n", "]", "return", "if", "limit", "is", "None", ":", "limit", "=", "n", "start", "=", "(", "n", "+", "size", "-", "1", ")", "//", "size", "stop", "=", "min", "(", "limit", ",", "n", "-", "size", "+", "1", ")", "+", "1", "for", "i", "in", "range", "(", "start", ",", "stop", ")", ":", "for", "tail", "in", "sum_to_n", "(", "n", "-", "i", ",", "size", "-", "1", ",", "i", ")", ":", "yield", "[", "i", "]", "+", "tail" ]

[ "Produce", "all", "lists", "of", "size", "positive", "integers", "in", "decreasing", "order", "that", "add", "up", "to", "n", "." ]

[ "def", "separate_walks_turns", "(", "data", ",", "window", "=", "[", "1", ",", "1", ",", "1", "]", ")", ":", "clusters", ",", "peaks", ",", "promi", "=", "cluster_walk_turn", "(", "data", ",", "window", "=", "window", ")", "group_one", "=", "[", "]", "group_two", "=", "[", "]", "start", "=", "0", "for", "i", "in", "range", "(", "1", ",", "len", "(", "clusters", ")", ")", ":", "if", "clusters", "[", "i", "-", "1", "]", "!=", "clusters", "[", "i", "]", ":", "assert", "np", ".", "all", "(", "clusters", "[", "start", ":", "i", "]", "==", "clusters", "[", "start", "]", ")", ",", "'Some values are mixed up, please check!'", "add", "=", "group_one", "if", "clusters", "[", "start", "]", "==", "0", "else", "group_two", "add", ".", "append", "(", "peaks", "[", "start", ":", "i", "]", ")", "start", "=", "i", "# hacky fix for the last part of the signal ...", "# I need to change this ...", "if", "i", "==", "len", "(", "clusters", ")", "-", "1", ":", "if", "not", "peaks", "[", "start", "]", "in", "add", "[", "-", "1", "]", ":", "add", "=", "group_one", "if", "clusters", "[", "start", "]", "==", "0", "else", "group_two", "add", ".", "append", "(", "peaks", "[", "start", ":", "]", ")", "maxes_one", "=", "[", "np", ".", "max", "(", "data", "[", "c", "]", ")", "for", "c", "in", "group_one", "]", "maxes_two", "=", "[", "np", ".", "max", "(", "data", "[", "c", "]", ")", "for", "c", "in", "group_two", "]", "walks", ",", "turns", "=", "group_two", ",", "group_one", "if", "np", ".", "max", "(", "maxes_one", ")", ">", "np", ".", "max", "(", "maxes_two", ")", ":", "walks", ",", "turns", "=", "group_one", ",", "group_two", "# let's drop any turns at the end of the signal", "# if len(turns[-1]) > len(walks[-1]):", "# turns.pop()", "return", "walks", ",", "turns" ]

[ "Will", "separate", "peaks", "into", "the", "clusters", "by", "following", "the", "trend", "in", "the", "clusters", "array", ".", "This", "is", "usedful", "because", "scipy", "s", "k", "-", "mean", "clustering", "will", "give", "us", "a", "continous", "clusters", "array", ".", ":", "param", "clusters", "array", ":", "A", "continous", "array", "representing", "different", "classes", ".", ":", "param", "peaks", "array", ":", "The", "peaks", "that", "we", "want", "to", "separate", "into", "the", "classes", "from", "the", "custers", ".", ":", "return", "walks", "arrays", ":", "An", "array", "of", "arrays", "that", "will", "have", "all", "the", "peaks", "corresponding", "to", "every", "individual", "walk", ".", ":", "return", "turns", "arraays", ":", "Array", "of", "array", "which", "has", "all", "the", "indices", "of", "the", "peaks", "that", "correspond", "to", "turning", "." ]

[ "def", "make_qscan_plot", "(", "workflow", ",", "ifo", ",", "trig_time", ",", "out_dir", ",", "injection_file", "=", "None", ",", "data_segments", "=", "None", ",", "time_window", "=", "100", ",", "tags", "=", "None", ")", ":", "tags", "=", "[", "]", "if", "tags", "is", "None", "else", "tags", "makedir", "(", "out_dir", ")", "name", "=", "'plot_qscan'", "curr_exe", "=", "PlotQScanExecutable", "(", "workflow", ".", "cp", ",", "name", ",", "ifos", "=", "[", "ifo", "]", ",", "out_dir", "=", "out_dir", ",", "tags", "=", "tags", ")", "node", "=", "curr_exe", ".", "create_node", "(", ")", "# Determine start/end times, using data segments if needed.", "# Begin by choosing \"optimal\" times", "start", "=", "trig_time", "-", "time_window", "end", "=", "trig_time", "+", "time_window", "# Then if data_segments is available, check against that, and move if", "# needed", "if", "data_segments", "is", "not", "None", ":", "# Assumes coalesced, so trig_time can only be within one segment", "for", "seg", "in", "data_segments", ":", "if", "trig_time", "in", "seg", ":", "data_seg", "=", "seg", "break", "elif", "trig_time", "==", "-", "1.0", ":", "node", ".", "add_opt", "(", "'--gps-start-time'", ",", "int", "(", "trig_time", ")", ")", "node", ".", "add_opt", "(", "'--gps-end-time'", ",", "int", "(", "trig_time", ")", ")", "node", ".", "add_opt", "(", "'--center-time'", ",", "trig_time", ")", "caption_string", "=", "\"'No trigger in %s'\"", "%", "ifo", "node", ".", "add_opt", "(", "'--plot-caption'", ",", "caption_string", ")", "node", ".", "new_output_file_opt", "(", "workflow", ".", "analysis_time", ",", "'.png'", ",", "'--output-file'", ")", "workflow", "+=", "node", "return", "node", ".", "output_files", "else", ":", "err_msg", "=", "\"Trig time {} \"", ".", "format", "(", "trig_time", ")", "err_msg", "+=", "\"does not seem to lie within any data segments. \"", "err_msg", "+=", "\"This shouldn't be possible, please ask for help!\"", "raise", "ValueError", "(", "err_msg", ")", "# Check for pad-data", "if", "curr_exe", ".", "has_opt", "(", "'pad-data'", ")", ":", "pad_data", "=", "int", "(", "curr_exe", ".", "get_opt", "(", "'pad-data'", ")", ")", "else", ":", "pad_data", "=", "0", "# We only read data that's available. The code must handle the case", "# of not much data being available.", "if", "end", ">", "(", "data_seg", "[", "1", "]", "-", "pad_data", ")", ":", "end", "=", "data_seg", "[", "1", "]", "-", "pad_data", "if", "start", "<", "(", "data_seg", "[", "0", "]", "+", "pad_data", ")", ":", "start", "=", "data_seg", "[", "0", "]", "+", "pad_data", "node", ".", "add_opt", "(", "'--gps-start-time'", ",", "int", "(", "start", ")", ")", "node", ".", "add_opt", "(", "'--gps-end-time'", ",", "int", "(", "end", ")", ")", "node", ".", "add_opt", "(", "'--center-time'", ",", "trig_time", ")", "if", "injection_file", "is", "not", "None", ":", "node", ".", "add_input_opt", "(", "'--injection-file'", ",", "injection_file", ")", "node", ".", "new_output_file_opt", "(", "workflow", ".", "analysis_time", ",", "'.png'", ",", "'--output-file'", ")", "workflow", "+=", "node", "return", "node", ".", "output_files" ]

[ "Generate", "a", "make_qscan", "node", "and", "add", "it", "to", "workflow", "." ]

[ "def", "insertSyntheticMemberAtBegin", "(", "self", ",", "synthesizedMember", ")", ":", "memberName", "=", "synthesizedMember", ".", "memberName", "(", ")", "if", "memberName", "in", "[", "m", ".", "memberName", "(", ")", "for", "m", "in", "self", ".", "_syntheticMemberList", "]", ":", "raise", "DuplicateMemberNameError", "(", "memberName", ",", "self", ".", "_class", ".", "__name__", ")", "self", ".", "_syntheticMemberList", ".", "insert", "(", "0", ",", "synthesizedMember", ")" ]

[ ":", "type", "synthesizedMember", ":", "SyntheticMember", ":", "raises", "DuplicateMemberNameError" ]

[ "def", "message", "(", "request", ",", "socket", ",", "context", ",", "message", ")", ":", "room", "=", "get_object_or_404", "(", "ChatRoom", ",", "id", "=", "message", "[", "\"room\"", "]", ")", "if", "message", "[", "\"action\"", "]", "==", "\"start\"", ":", "name", "=", "strip_tags", "(", "message", "[", "\"name\"", "]", ")", "user", ",", "created", "=", "room", ".", "users", ".", "get_or_create", "(", "name", "=", "name", ")", "if", "not", "created", ":", "socket", ".", "send", "(", "{", "\"action\"", ":", "\"in-use\"", "}", ")", "else", ":", "context", "[", "\"user\"", "]", "=", "user", "users", "=", "[", "u", ".", "name", "for", "u", "in", "room", ".", "users", ".", "exclude", "(", "id", "=", "user", ".", "id", ")", "]", "socket", ".", "send", "(", "{", "\"action\"", ":", "\"started\"", ",", "\"users\"", ":", "users", "}", ")", "user", ".", "session", "=", "socket", ".", "session", ".", "session_id", "user", ".", "save", "(", ")", "joined", "=", "{", "\"action\"", ":", "\"join\"", ",", "\"name\"", ":", "user", ".", "name", ",", "\"id\"", ":", "user", ".", "id", "}", "socket", ".", "send_and_broadcast_channel", "(", "joined", ")", "else", ":", "try", ":", "user", "=", "context", "[", "\"user\"", "]", "except", "KeyError", ":", "return", "if", "message", "[", "\"action\"", "]", "==", "\"message\"", ":", "message", "[", "\"message\"", "]", "=", "strip_tags", "(", "message", "[", "\"message\"", "]", ")", "message", "[", "\"name\"", "]", "=", "user", ".", "name", "socket", ".", "send_and_broadcast_channel", "(", "message", ")" ]

[ "Event", "handler", "for", "a", "room", "receiving", "a", "message", ".", "First", "validates", "a", "joining", "user", "s", "name", "and", "sends", "them", "the", "list", "of", "users", "." ]

[ "def", "run_cli", "(", "executable", ",", "mets_url", "=", "None", ",", "resolver", "=", "None", ",", "workspace", "=", "None", ",", "page_id", "=", "None", ",", "log_level", "=", "None", ",", "input_file_grp", "=", "None", ",", "output_file_grp", "=", "None", ",", "parameter", "=", "None", ",", "working_dir", "=", "None", ",", ")", ":", "workspace", "=", "_get_workspace", "(", "workspace", ",", "resolver", ",", "mets_url", ",", "working_dir", ")", "args", "=", "[", "executable", ",", "'--working-dir'", ",", "workspace", ".", "directory", "]", "args", "+=", "[", "'--mets'", ",", "mets_url", "]", "if", "log_level", ":", "args", "+=", "[", "'--log-level'", ",", "log_level", "]", "if", "page_id", ":", "args", "+=", "[", "'--page-id'", ",", "page_id", "]", "if", "input_file_grp", ":", "args", "+=", "[", "'--input-file-grp'", ",", "input_file_grp", "]", "if", "output_file_grp", ":", "args", "+=", "[", "'--output-file-grp'", ",", "output_file_grp", "]", "if", "parameter", ":", "args", "+=", "[", "'--parameter'", ",", "parameter", "]", "log", ".", "debug", "(", "\"Running subprocess '%s'\"", ",", "' '", ".", "join", "(", "args", ")", ")", "return", "subprocess", ".", "call", "(", "args", ")" ]

[ "Create", "a", "workspace", "for", "mets_url", "and", "run", "MP", "CLI", "through", "it" ]

[ "def", "start_all", "(", "self", ")", ":", "pool", "=", "Pool", "(", "concurrency", "=", "3", ")", "for", "node", "in", "self", ".", "nodes", ".", "values", "(", ")", ":", "pool", ".", "append", "(", "node", ".", "start", ")", "yield", "from", "pool", ".", "join", "(", ")" ]

[ "Start", "all", "nodes" ]

[ "def", "to_unicode_from_fs", "(", "string", ")", ":", "if", "not", "is_string", "(", "string", ")", ":", "# string is a QString\r", "string", "=", "to_text_string", "(", "string", ".", "toUtf8", "(", ")", ",", "'utf-8'", ")", "else", ":", "if", "is_binary_string", "(", "string", ")", ":", "try", ":", "unic", "=", "string", ".", "decode", "(", "FS_ENCODING", ")", "except", "(", "UnicodeError", ",", "TypeError", ")", ":", "pass", "else", ":", "return", "unic", "return", "string" ]

[ "Return", "a", "unicode", "version", "of", "string", "decoded", "using", "the", "file", "system", "encoding", "." ]

[ "def", "_normalize", "(", "self", ",", "name", ")", ":", "name", "=", "re", ".", "sub", "(", "r'^(Senator|Representative|Sen\\.?|Rep\\.?|'", "'Hon\\.?|Right Hon\\.?|Mr\\.?|Mrs\\.?|Ms\\.?|L\\'hon\\.?|'", "'Assembly(member|man|woman)) '", ",", "''", ",", "name", ")", "return", "name", ".", "strip", "(", ")", ".", "lower", "(", ")", ".", "replace", "(", "'.'", ",", "''", ")" ]

[ "Normalizes", "a", "legislator", "name", "by", "stripping", "titles", "from", "the", "front", "converting", "to", "lowercase", "and", "removing", "punctuation", "." ]

[ "def", "symbol_to_id", "(", "self", ",", "symbol", ")", ":", "if", "symbol", "not", "in", "self", ".", "symbols_to_ids", ":", "m", "=", "'Could not look up Entrez ID for Geneways symbol '", "+", "symbol", "raise", "Exception", "(", "m", ")", "return", "self", ".", "symbols_to_ids", "[", "symbol", "]" ]

[ "Returns", "the", "list", "of", "Entrez", "IDs", "for", "a", "given", "Geneways", "symbol", "(", "there", "may", "be", "more", "than", "one", ")" ]

[ "def", "from_altaz", "(", "self", ",", "alt", "=", "None", ",", "az", "=", "None", ",", "alt_degrees", "=", "None", ",", "az_degrees", "=", "None", ",", "distance", "=", "Distance", "(", "au", "=", "0.1", ")", ")", ":", "# TODO: should this method live on another class?", "R", "=", "self", ".", "observer_data", ".", "altaz_rotation", "if", "self", ".", "observer_data", "else", "None", "if", "R", "is", "None", ":", "raise", "ValueError", "(", "'only a position generated by a topos() call'", "' knows the orientation of the horizon'", "' and can understand altitude and azimuth'", ")", "alt", "=", "_interpret_angle", "(", "'alt'", ",", "alt", ",", "alt_degrees", ")", "az", "=", "_interpret_angle", "(", "'az'", ",", "az", ",", "az_degrees", ")", "r", "=", "distance", ".", "au", "p", "=", "from_polar", "(", "r", ",", "alt", ",", "az", ")", "p", "=", "einsum", "(", "'ji...,j...->i...'", ",", "R", ",", "p", ")", "return", "Apparent", "(", "p", ")" ]

[ "Generate", "an", "Apparent", "position", "from", "an", "altitude", "and", "azimuth", "." ]

[ "def", "get_area_code", "(", "self", ",", "ip", ")", ":", "rec", "=", "self", ".", "get_all", "(", "ip", ")", "return", "rec", "and", "rec", ".", "area_code" ]

[ "Get", "area_code" ]

[ "def", "response", "(", "self", ",", "payload", ")", ":", "if", "self", ".", "_state", "==", "SASLState", ".", "SUCCESS_SIMULATE_CHALLENGE", ":", "if", "payload", "!=", "b\"\"", ":", "# XXX: either our mechanism is buggy or the server", "# sent SASLState.SUCCESS before all challenge-response", "# messages defined by the mechanism were sent", "self", ".", "_state", "=", "SASLState", ".", "FAILURE", "raise", "SASLFailure", "(", "None", ",", "\"protocol violation: mechanism did not\"", "\" respond with an empty response to a\"", "\" challenge with final data – this suggests\"", "\" a protocol-violating early success from the server.\"", ")", "self", ".", "_state", "=", "SASLState", ".", "SUCCESS", "return", "SASLState", ".", "SUCCESS", ",", "None", "if", "self", ".", "_state", "!=", "SASLState", ".", "CHALLENGE", ":", "raise", "RuntimeError", "(", "\"no challenge has been made or negotiation failed\"", ")", "try", ":", "next_state", ",", "payload", "=", "yield", "from", "self", ".", "interface", ".", "respond", "(", "payload", ")", "except", "SASLFailure", ":", "self", ".", "_state", "=", "SASLState", ".", "FAILURE", "raise", "next_state", "=", "SASLState", ".", "from_reply", "(", "next_state", ")", "# unfold the (SASLState.SUCCESS, payload) to a sequence of", "# (SASLState.CHALLENGE, payload), (SASLState.SUCCESS, None) for the SASLMethod", "# to allow uniform treatment of both cases", "if", "next_state", "==", "SASLState", ".", "SUCCESS", "and", "payload", "is", "not", "None", ":", "self", ".", "_state", "=", "SASLState", ".", "SUCCESS_SIMULATE_CHALLENGE", "return", "SASLState", ".", "CHALLENGE", ",", "payload", "self", ".", "_state", "=", "next_state", "return", "next_state", ",", "payload" ]

[ "Send", "a", "response", "to", "the", "previously", "received", "challenge", "with", "the", "given", "payload", ".", "The", "payload", "is", "encoded", "using", "base64", "and", "transmitted", "to", "the", "server", "." ]

[ "def", "register_task_with_maintenance_window", "(", "WindowId", "=", "None", ",", "Targets", "=", "None", ",", "TaskArn", "=", "None", ",", "ServiceRoleArn", "=", "None", ",", "TaskType", "=", "None", ",", "TaskParameters", "=", "None", ",", "Priority", "=", "None", ",", "MaxConcurrency", "=", "None", ",", "MaxErrors", "=", "None", ",", "LoggingInfo", "=", "None", ",", "ClientToken", "=", "None", ")", ":", "pass" ]

[ "Adds", "a", "new", "task", "to", "a", "Maintenance", "Window", ".", "See", "also", ":", "AWS", "API", "Documentation", ":", "example", ":", "response", "=", "client", ".", "register_task_with_maintenance_window", "(", "WindowId", "=", "string", "Targets", "=", "[", "{", "Key", ":", "string", "Values", ":", "[", "string", "]", "}", "]", "TaskArn", "=", "string", "ServiceRoleArn", "=", "string", "TaskType", "=", "RUN_COMMAND", "TaskParameters", "=", "{", "string", ":", "{", "Values", ":", "[", "string", "]", "}", "}", "Priority", "=", "123", "MaxConcurrency", "=", "string", "MaxErrors", "=", "string", "LoggingInfo", "=", "{", "S3BucketName", ":", "string", "S3KeyPrefix", ":", "string", "S3Region", ":", "string", "}", "ClientToken", "=", "string", ")", ":", "type", "WindowId", ":", "string", ":", "param", "WindowId", ":", "[", "REQUIRED", "]", "The", "id", "of", "the", "Maintenance", "Window", "the", "task", "should", "be", "added", "to", "." ]

[ "def", "set_font_face", "(", "self", ",", "font_face", ")", ":", "font_face", "=", "font_face", ".", "_pointer", "if", "font_face", "is", "not", "None", "else", "ffi", ".", "NULL", "cairo", ".", "cairo_set_font_face", "(", "self", ".", "_pointer", ",", "font_face", ")", "self", ".", "_check_status", "(", ")" ]

[ "Replaces", "the", "current", "font", "face", "with", ":", "obj", ":", "font_face", "." ]

[ "def", "p_struct", "(", "self", ",", "p", ")", ":", "p", "[", "0", "]", "=", "ast", ".", "Struct", "(", "name", "=", "p", "[", "2", "]", ",", "fields", "=", "p", "[", "4", "]", ",", "annotations", "=", "p", "[", "6", "]", ",", "lineno", "=", "p", ".", "lineno", "(", "2", ")", ")" ]

[ "struct", ":", "STRUCT", "IDENTIFIER", "{", "field_seq", "}", "annotations" ]

[ "def", "create_change_set", "(", "StackName", "=", "None", ",", "TemplateBody", "=", "None", ",", "TemplateURL", "=", "None", ",", "UsePreviousTemplate", "=", "None", ",", "Parameters", "=", "None", ",", "Capabilities", "=", "None", ",", "ResourceTypes", "=", "None", ",", "RoleARN", "=", "None", ",", "NotificationARNs", "=", "None", ",", "Tags", "=", "None", ",", "ChangeSetName", "=", "None", ",", "ClientToken", "=", "None", ",", "Description", "=", "None", ",", "ChangeSetType", "=", "None", ")", ":", "pass" ]

[ "Creates", "a", "list", "of", "changes", "that", "will", "be", "applied", "to", "a", "stack", "so", "that", "you", "can", "review", "the", "changes", "before", "executing", "them", ".", "You", "can", "create", "a", "change", "set", "for", "a", "stack", "that", "doesn", "t", "exist", "or", "an", "existing", "stack", ".", "If", "you", "create", "a", "change", "set", "for", "a", "stack", "that", "doesn", "t", "exist", "the", "change", "set", "shows", "all", "of", "the", "resources", "that", "AWS", "CloudFormation", "will", "create", ".", "If", "you", "create", "a", "change", "set", "for", "an", "existing", "stack", "AWS", "CloudFormation", "compares", "the", "stack", "s", "information", "with", "the", "information", "that", "you", "submit", "in", "the", "change", "set", "and", "lists", "the", "differences", ".", "Use", "change", "sets", "to", "understand", "which", "resources", "AWS", "CloudFormation", "will", "create", "or", "change", "and", "how", "it", "will", "change", "resources", "in", "an", "existing", "stack", "before", "you", "create", "or", "update", "a", "stack", ".", "To", "create", "a", "change", "set", "for", "a", "stack", "that", "doesn", "t", "exist", "for", "the", "ChangeSetType", "parameter", "specify", "CREATE", ".", "To", "create", "a", "change", "set", "for", "an", "existing", "stack", "specify", "UPDATE", "for", "the", "ChangeSetType", "parameter", ".", "After", "the", "CreateChangeSet", "call", "successfully", "completes", "AWS", "CloudFormation", "starts", "creating", "the", "change", "set", ".", "To", "check", "the", "status", "of", "the", "change", "set", "or", "to", "review", "it", "use", "the", "DescribeChangeSet", "action", ".", "When", "you", "are", "satisfied", "with", "the", "changes", "the", "change", "set", "will", "make", "execute", "the", "change", "set", "by", "using", "the", "ExecuteChangeSet", "action", ".", "AWS", "CloudFormation", "doesn", "t", "make", "changes", "until", "you", "execute", "the", "change", "set", ".", "See", "also", ":", "AWS", "API", "Documentation", ":", "example", ":", "response", "=", "client", ".", "create_change_set", "(", "StackName", "=", "string", "TemplateBody", "=", "string", "TemplateURL", "=", "string", "UsePreviousTemplate", "=", "True|False", "Parameters", "=", "[", "{", "ParameterKey", ":", "string", "ParameterValue", ":", "string", "UsePreviousValue", ":", "True|False", "}", "]", "Capabilities", "=", "[", "CAPABILITY_IAM", "|", "CAPABILITY_NAMED_IAM", "]", "ResourceTypes", "=", "[", "string", "]", "RoleARN", "=", "string", "NotificationARNs", "=", "[", "string", "]", "Tags", "=", "[", "{", "Key", ":", "string", "Value", ":", "string", "}", "]", "ChangeSetName", "=", "string", "ClientToken", "=", "string", "Description", "=", "string", "ChangeSetType", "=", "CREATE", "|", "UPDATE", ")", ":", "type", "StackName", ":", "string", ":", "param", "StackName", ":", "[", "REQUIRED", "]", "The", "name", "or", "the", "unique", "ID", "of", "the", "stack", "for", "which", "you", "are", "creating", "a", "change", "set", ".", "AWS", "CloudFormation", "generates", "the", "change", "set", "by", "comparing", "this", "stack", "s", "information", "with", "the", "information", "that", "you", "submit", "such", "as", "a", "modified", "template", "or", "different", "parameter", "input", "values", "." ]

[ "def", "draw_image", "(", "self", ",", "metric", ",", "limit", "=", "5", ")", ":", "rows", "=", "1", "cols", "=", "limit", "self", ".", "ax", ".", "axis", "(", "\"off\"", ")", "# Take the Axes gridspec and divide it into a grid", "gs", "=", "matplotlib", ".", "gridspec", ".", "GridSpecFromSubplotSpec", "(", "rows", ",", "cols", ",", "subplot_spec", "=", "self", ".", "gs", ")", "# Loop through images in last few steps", "for", "i", ",", "image", "in", "enumerate", "(", "metric", ".", "data", "[", "-", "cols", ":", "]", ")", ":", "ax", "=", "self", ".", "figure", ".", "add_subplot", "(", "gs", "[", "0", ",", "i", "]", ")", "ax", ".", "axis", "(", "'off'", ")", "ax", ".", "set_title", "(", "metric", ".", "formatted_steps", "[", "-", "cols", ":", "]", "[", "i", "]", ")", "ax", ".", "imshow", "(", "norm", "(", "image", ")", ")" ]

[ "Display", "a", "series", "of", "images", "at", "different", "time", "steps", "." ]

[ "def", "execute", "(", "self", ",", "output_options", "=", "None", ",", "sampling", "=", "None", ",", "context", "=", "None", ",", "query_params", "=", "None", ")", ":", "return", "self", ".", "execute_async", "(", "output_options", ",", "sampling", "=", "sampling", ",", "context", "=", "context", ",", "query_params", "=", "query_params", ")", ".", "wait", "(", ")" ]

[ "Initiate", "the", "query", "and", "return", "a", "QueryJob", "." ]

[ "def", "logdet", "(", "self", ")", ":", "from", "numpy", ".", "linalg", "import", "slogdet", "K", "=", "self", ".", "value", "(", ")", "sign", ",", "logdet", "=", "slogdet", "(", "K", ")", "if", "sign", "!=", "1.0", ":", "msg", "=", "\"The estimated determinant of K is not positive: \"", "msg", "+=", "f\" ({sign}, {logdet}).\"", "raise", "RuntimeError", "(", "msg", ")", "return", "logdet" ]

[ "Log", "of", "｜K｜", "." ]

[ "def", "preview", "(", ")", ":", "# pragma: no coverage", "Handler", "=", "http", ".", "server", ".", "SimpleHTTPRequestHandler", "socketserver", ".", "TCPServer", ".", "allow_reuse_address", "=", "True", "port", "=", "CONFIG", "[", "'http_port'", "]", "httpd", "=", "socketserver", ".", "TCPServer", "(", "(", "\"\"", ",", "port", ")", ",", "Handler", ")", "os", ".", "chdir", "(", "CONFIG", "[", "'output_to'", "]", ")", "try", ":", "logger", ".", "info", "(", "\"and ready to test at \"", "\"http://127.0.0.1:%d\"", "%", "CONFIG", "[", "'http_port'", "]", ")", "logger", ".", "info", "(", "\"Hit Ctrl+C to exit\"", ")", "httpd", ".", "serve_forever", "(", ")", "except", "KeyboardInterrupt", ":", "httpd", ".", "shutdown", "(", ")" ]

[ "launch", "an", "HTTP", "to", "preview", "the", "website" ]

[ "def", "echo_via_pager", "(", "text_or_generator", ",", "color", "=", "None", ")", ":", "color", "=", "resolve_color_default", "(", "color", ")", "if", "inspect", ".", "isgeneratorfunction", "(", "text_or_generator", ")", ":", "i", "=", "text_or_generator", "(", ")", "elif", "isinstance", "(", "text_or_generator", ",", "string_types", ")", ":", "i", "=", "[", "text_or_generator", "]", "else", ":", "i", "=", "iter", "(", "text_or_generator", ")", "# convert every element of i to a text type if necessary", "text_generator", "=", "(", "el", "if", "isinstance", "(", "el", ",", "string_types", ")", "else", "text_type", "(", "el", ")", "for", "el", "in", "i", ")", "from", ".", "_termui_impl", "import", "pager", "return", "pager", "(", "itertools", ".", "chain", "(", "text_generator", ",", "\"\\n\"", ")", ",", "color", ")" ]

[ "This", "function", "takes", "a", "text", "and", "shows", "it", "via", "an", "environment", "specific", "pager", "on", "stdout", "." ]

[ "def", "find_all", "(", "connection", "=", "None", ",", "page_size", "=", "100", ",", "page_number", "=", "0", ",", "sort_by", "=", "DEFAULT_SORT_BY", ",", "sort_order", "=", "DEFAULT_SORT_ORDER", ")", ":", "return", "pybrightcove", ".", "connection", ".", "ItemResultSet", "(", "\"find_all_playlists\"", ",", "Playlist", ",", "connection", ",", "page_size", ",", "page_number", ",", "sort_by", ",", "sort_order", ")" ]

[ "List", "all", "playlists", "." ]

[ "def", "_verify_subnet_association", "(", "route_table_desc", ",", "subnet_id", ")", ":", "if", "route_table_desc", ":", "if", "'associations'", "in", "route_table_desc", ":", "for", "association", "in", "route_table_desc", "[", "'associations'", "]", ":", "if", "association", "[", "'subnet_id'", "]", "==", "subnet_id", ":", "return", "True", "return", "False" ]

[ "Helper", "function", "verify", "a", "subnet", "s", "route", "table", "association" ]

[ "def", "set_posts_param_modified_after", "(", "self", ",", "params", ",", "post_type", ",", "status", ")", ":", "if", "not", "self", ".", "purge_first", "and", "not", "self", ".", "full", "and", "not", "self", ".", "modified_after", ":", "if", "status", "==", "\"any\"", ":", "latest", "=", "Post", ".", "objects", ".", "filter", "(", "post_type", "=", "post_type", ")", ".", "order_by", "(", "\"-modified\"", ")", ".", "first", "(", ")", "else", ":", "latest", "=", "Post", ".", "objects", ".", "filter", "(", "post_type", "=", "post_type", ",", "status", "=", "status", ")", ".", "order_by", "(", "\"-modified\"", ")", ".", "first", "(", ")", "if", "latest", ":", "self", ".", "modified_after", "=", "latest", ".", "modified", "if", "self", ".", "modified_after", ":", "params", "[", "\"modified_after\"", "]", "=", "self", ".", "modified_after", ".", "isoformat", "(", ")", "logger", ".", "info", "(", "\"getting posts after: %s\"", ",", "params", "[", "\"modified_after\"", "]", ")" ]

[ "Set", "modified_after", "date", "to", "continue", "where", "we", "left", "off", "if", "appropriate" ]

[ "def", "build", "(", "self", ",", "builder", ")", ":", "params", "=", "dict", "(", "OID", "=", "self", ".", "oid", ")", "if", "self", ".", "user_type", ":", "params", ".", "update", "(", "dict", "(", "UserType", "=", "self", ".", "user_type", ".", "value", ")", ")", "builder", ".", "start", "(", "self", ".", "__class__", ".", "__name__", ",", "params", ")", "# build the children", "for", "child", "in", "(", "'login_name'", ",", "'display_name'", ",", "'full_name'", ",", "'first_name'", ",", "'last_name'", ",", "'organisation'", ")", ":", "if", "getattr", "(", "self", ",", "child", ")", "is", "not", "None", ":", "getattr", "(", "self", ",", "child", ")", ".", "build", "(", "builder", ")", "for", "address", "in", "self", ".", "addresses", ":", "address", ".", "build", "(", "builder", ")", "for", "email", "in", "self", ".", "emails", ":", "email", ".", "build", "(", "builder", ")", "for", "phone", "in", "self", ".", "phones", ":", "phone", ".", "build", "(", "builder", ")", "for", "location", "in", "self", ".", "locations", ":", "location", ".", "build", "(", "builder", ")", "builder", ".", "end", "(", "self", ".", "__class__", ".", "__name__", ")" ]

[ "Build", "XML", "by", "appending", "to", "builder" ]

[ "def", "proximal_l1_l2", "(", "space", ",", "lam", "=", "1", ",", "g", "=", "None", ")", ":", "lam", "=", "float", "(", "lam", ")", "if", "g", "is", "not", "None", "and", "g", "not", "in", "space", ":", "raise", "TypeError", "(", "'{!r} is not an element of {!r}'", ".", "format", "(", "g", ",", "space", ")", ")", "class", "ProximalL1L2", "(", "Operator", ")", ":", "\"\"\"Proximal operator of the group-L1-L2 norm/distance.\"\"\"", "def", "__init__", "(", "self", ",", "sigma", ")", ":", "\"\"\"Initialize a new instance.\n\n Parameters\n ----------\n sigma : positive float\n Step size parameter.\n \"\"\"", "super", "(", "ProximalL1L2", ",", "self", ")", ".", "__init__", "(", "domain", "=", "space", ",", "range", "=", "space", ",", "linear", "=", "False", ")", "self", ".", "sigma", "=", "float", "(", "sigma", ")", "def", "_call", "(", "self", ",", "x", ",", "out", ")", ":", "\"\"\"Return ``self(x, out=out)``.\"\"\"", "# diff = x - g", "if", "g", "is", "not", "None", ":", "diff", "=", "x", "-", "g", "else", ":", "if", "x", "is", "out", ":", "# Handle aliased `x` and `out` (original `x` needed later)", "diff", "=", "x", ".", "copy", "(", ")", "else", ":", "diff", "=", "x", "# We write the operator as", "# x - (x - g) / max(|x - g|_2 / sig*lam, 1)", "pwnorm", "=", "PointwiseNorm", "(", "self", ".", "domain", ",", "exponent", "=", "2", ")", "denom", "=", "pwnorm", "(", "diff", ")", "denom", "/=", "self", ".", "sigma", "*", "lam", "denom", ".", "ufuncs", ".", "maximum", "(", "1", ",", "out", "=", "denom", ")", "# out = (x - g) / denom", "for", "out_i", ",", "diff_i", "in", "zip", "(", "out", ",", "diff", ")", ":", "diff_i", ".", "divide", "(", "denom", ",", "out", "=", "out_i", ")", "# out = x - ...", "out", ".", "lincomb", "(", "1", ",", "x", ",", "-", "1", ",", "out", ")", "return", "ProximalL1L2" ]

[ "r", "Proximal", "operator", "factory", "of", "the", "group", "-", "L1", "-", "L2", "norm", "/", "distance", "." ]

[ "def", "_parse_from_file", "(", "self", ",", "file_path", ")", ":", "file_path", "=", "abspath", "(", "file_path", ")", "if", "not", "isfile", "(", "file_path", ")", ":", "raise", "MarkovTextExcept", "(", "\"Передан не файл.\")", "", "with", "open", "(", "file_path", ",", "\"rb\"", ")", "as", "txt_file", ":", "for", "line", "in", "txt_file", ":", "text", "=", "line", ".", "decode", "(", "\"utf-8\"", ",", "\"ignore\"", ")", ".", "strip", "(", ")", "if", "not", "text", ":", "continue", "yield", "from", "self", ".", "_parse_from_text", "(", "text", ")" ]

[ "см", ".", "описание", "_parse_from_text", ".", "Только", "на", "вход", "подаётся", "не", "текст", "а", "путь", "к", "файлу", "." ]

[ "def", "arrows", "(", "self", ")", ":", "for", "o", "in", "self", ".", "arrow", ".", "values", "(", ")", ":", "for", "arro", "in", "o", ".", "values", "(", ")", ":", "yield", "arro" ]

[ "Iterate", "over", "all", "my", "arrows", "." ]

[ "def", "_message_received", "(", "self", ",", "message", ")", ":", "with", "self", ".", "lock", ":", "self", ".", "_state", ".", "receive_message", "(", "message", ")", "for", "callable", "in", "chain", "(", "self", ".", "_on_message_received", ",", "self", ".", "_on_message", ")", ":", "callable", "(", "message", ")" ]

[ "Notify", "the", "observers", "about", "the", "received", "message", "." ]

[ "def", "checksum", "(", "data", ",", "start", "=", "0", ",", "skip_word", "=", "None", ")", ":", "if", "len", "(", "data", ")", "%", "2", "!=", "0", ":", "arr", "=", "array", ".", "array", "(", "'H'", ",", "data", "[", ":", "-", "1", "]", ")", "else", ":", "arr", "=", "array", ".", "array", "(", "'H'", ",", "data", ")", "if", "skip_word", "is", "not", "None", ":", "for", "i", "in", "range", "(", "0", ",", "len", "(", "arr", ")", ")", ":", "if", "i", "==", "skip_word", ":", "continue", "start", "+=", "arr", "[", "i", "]", "else", ":", "for", "i", "in", "range", "(", "0", ",", "len", "(", "arr", ")", ")", ":", "start", "+=", "arr", "[", "i", "]", "if", "len", "(", "data", ")", "%", "2", "!=", "0", ":", "start", "+=", "struct", ".", "unpack", "(", "'H'", ",", "data", "[", "-", "1", ":", "]", "+", "b'\\x00'", ")", "[", "0", "]", "# Specify order?", "start", "=", "(", "start", ">>", "16", ")", "+", "(", "start", "&", "0xffff", ")", "start", "+=", "(", "start", ">>", "16", ")", "#while start >> 16:", "# start = (start >> 16) + (start & 0xffff)", "return", "ntohs", "(", "~", "start", "&", "0xffff", ")" ]

[ "Calculate", "standard", "internet", "checksum", "over", "data", "starting", "at", "start", "th", "byte" ]

[ "def", "get", "(", "key", ",", "default", "=", "-", "1", ")", ":", "if", "isinstance", "(", "key", ",", "int", ")", ":", "return", "Parameter", "(", "key", ")", "if", "key", "not", "in", "Parameter", ".", "_member_map_", ":", "extend_enum", "(", "Parameter", ",", "key", ",", "default", ")", "return", "Parameter", "[", "key", "]" ]

[ "Backport", "support", "for", "original", "codes", "." ]

[ "def", "check_auth_gssapi_with_mic", "(", "self", ",", "username", ",", "gss_authenticated", "=", "AUTH_FAILED", ",", "cc_file", "=", "None", ")", ":", "if", "gss_authenticated", "==", "AUTH_SUCCESSFUL", ":", "return", "AUTH_SUCCESSFUL", "return", "AUTH_FAILED" ]

[ "Authenticate", "the", "given", "user", "to", "the", "server", "if", "he", "is", "a", "valid", "krb5", "principal", "." ]

[ "def", "draw_diagram_nodes", "(", "graph", ",", "pos", "=", "None", ",", "nodelist", "=", "None", ",", "node_size", "=", ".7", ",", "node_color", "=", "'k'", ",", "style", "=", "'solid'", ",", "alpha", "=", "1.0", ",", "cmap", "=", "None", ",", "vmin", "=", "None", ",", "vmax", "=", "None", ",", "ax", "=", "None", ",", "label", "=", "None", ")", ":", "if", "ax", "is", "None", ":", "ax", "=", "_plt", ".", "gca", "(", ")", "if", "nodelist", "is", "None", ":", "nodelist", "=", "list", "(", "graph", ".", "nodes", "(", ")", ")", "if", "not", "nodelist", "or", "len", "(", "nodelist", ")", "==", "0", ":", "# empty nodelist, no drawing", "return", "None", "if", "pos", "is", "None", ":", "pos", "=", "diagram_layout", "(", "graph", ")", "try", ":", "xy", "=", "_np", ".", "asarray", "(", "[", "pos", "[", "v", "]", "for", "v", "in", "nodelist", "]", ")", "except", "KeyError", "as", "e", ":", "raise", "_nx", ".", "NetworkXError", "(", "'Node {} has no position.'", ".", "format", "(", "e", ")", ")", "except", "ValueError", ":", "raise", "_nx", ".", "NetworkXError", "(", "'Bad value in node positions.'", ")", "if", "isinstance", "(", "alpha", ",", "_collections", ".", "Iterable", ")", ":", "node_color", "=", "_nx", ".", "drawing", ".", "apply_alpha", "(", "node_color", ",", "alpha", ",", "nodelist", ",", "cmap", ",", "vmin", ",", "vmax", ")", "alpha", "=", "None", "node_collection", "=", "ax", ".", "hlines", "(", "xy", "[", ":", ",", "1", "]", ",", "xy", "[", ":", ",", "0", "]", "-", "node_size", "/", "2.", ",", "xy", "[", ":", ",", "0", "]", "+", "node_size", "/", "2.", ",", "colors", "=", "node_color", ",", "linestyles", "=", "style", ",", "label", "=", "label", ",", "cmap", "=", "cmap", ")", "node_collection", ".", "set_zorder", "(", "2", ")", "return", "node_collection" ]

[ "Draw", "nodes", "of", "graph", "." ]

[ "def", "astensor", "(", "array", ":", "TensorLike", ")", "->", "BKTensor", ":", "array", "=", "np", ".", "asarray", "(", "array", ",", "dtype", "=", "CTYPE", ")", "return", "array" ]

[ "Converts", "a", "numpy", "array", "to", "the", "backend", "s", "tensor", "object" ]

[ "def", "mcons", "(", "self", ",", "iterable", ")", ":", "head", "=", "self", "for", "elem", "in", "iterable", ":", "head", "=", "head", ".", "cons", "(", "elem", ")", "return", "head" ]

[ "Return", "a", "new", "list", "with", "all", "elements", "of", "iterable", "repeatedly", "cons", ":", "ed", "to", "the", "current", "list", ".", "NB!", "The", "elements", "will", "be", "inserted", "in", "the", "reverse", "order", "of", "the", "iterable", ".", "Runs", "in", "O", "(", "len", "(", "iterable", "))", "." ]

[ "def", "public_key", "(", "self", ")", ":", "if", "not", "self", ".", "_public_key", "and", "self", ".", "x509", ":", "evp_pkey", "=", "libcrypto", ".", "X509_get_pubkey", "(", "self", ".", "x509", ")", "self", ".", "_public_key", "=", "PublicKey", "(", "evp_pkey", ",", "self", ".", "asn1", "[", "'tbs_certificate'", "]", "[", "'subject_public_key_info'", "]", ")", "return", "self", ".", "_public_key" ]

[ ":", "return", ":", "The", "PublicKey", "object", "for", "the", "public", "key", "this", "certificate", "contains" ]

[ "def", "getSchemaItem", "(", "self", ",", "collection", ",", "namespace", ",", "name", ")", ":", "parent", "=", "GetSchema", "(", "self", ")", "if", "parent", ".", "targetNamespace", "==", "namespace", ":", "try", ":", "obj", "=", "getattr", "(", "parent", ",", "collection", ")", "[", "name", "]", "except", "KeyError", ",", "ex", ":", "raise", "KeyError", ",", "'targetNamespace(%s) collection(%s) has no item(%s)'", "%", "(", "namespace", ",", "collection", ",", "name", ")", "return", "obj", "if", "not", "parent", ".", "imports", ".", "has_key", "(", "namespace", ")", ":", "if", "namespace", "in", "BUILT_IN_NAMESPACES", ":", "# built-in just return", "# WARNING: expecting import if \"redefine\" or add to built-in namespace.", "return", "raise", "SchemaError", ",", "'schema \"%s\" does not import namespace \"%s\"'", "%", "(", "parent", ".", "targetNamespace", ",", "namespace", ")", "# Lazy Eval", "schema", "=", "parent", ".", "imports", "[", "namespace", "]", "if", "not", "isinstance", "(", "schema", ",", "XMLSchema", ")", ":", "schema", "=", "schema", ".", "getSchema", "(", ")", "if", "schema", "is", "not", "None", ":", "parent", ".", "imports", "[", "namespace", "]", "=", "schema", "if", "schema", "is", "None", ":", "if", "namespace", "in", "BUILT_IN_NAMESPACES", ":", "# built-in just return", "return", "raise", "SchemaError", ",", "'no schema instance for imported namespace (%s).'", "%", "(", "namespace", ")", "if", "not", "isinstance", "(", "schema", ",", "XMLSchema", ")", ":", "raise", "TypeError", ",", "'expecting XMLSchema instance not \"%r\"'", "%", "schema", "try", ":", "obj", "=", "getattr", "(", "schema", ",", "collection", ")", "[", "name", "]", "except", "KeyError", ",", "ex", ":", "raise", "KeyError", ",", "'targetNamespace(%s) collection(%s) has no item(%s)'", "%", "(", "namespace", ",", "collection", ",", "name", ")", "return", "obj" ]

[ "returns", "object", "instance", "representing", "namespace", "name", "or", "if", "does", "not", "exist", "return", "None", "if", "built", "-", "in", "else", "raise", "SchemaError", ".", "namespace", "--", "namespace", "item", "defined", "in", ".", "name", "--", "name", "of", "item", ".", "collection", "--", "collection", "in", "parent", "Schema", "instance", "to", "search", "." ]

[ "def", "list", "(", "self", ",", "filters", ",", "cursor", ",", "count", ")", ":", "assert", "isinstance", "(", "filters", ",", "dict", ")", ",", "\"expected filters type 'dict'\"", "assert", "isinstance", "(", "cursor", ",", "dict", ")", ",", "\"expected cursor type 'dict'\"", "# start with our base query", "query", "=", "self", ".", "get_query", "(", ")", "assert", "isinstance", "(", "query", ",", "peewee", ".", "Query", ")", "# XXX: convert and apply user specified filters", "#filters = {field.name: cursor[field.name] for field in fields}", "#query.where(", "paginator", "=", "self", ".", "get_paginator", "(", ")", "assert", "isinstance", "(", "paginator", ",", "Pagination", ")", "# always include an extra row for next cursor position", "count", "+=", "1", "# apply pagination to query", "pquery", "=", "paginator", ".", "filter_query", "(", "query", ",", "cursor", ",", "count", ")", "items", "=", "[", "item", "for", "item", "in", "pquery", "]", "# determine next cursor position", "next_item", "=", "items", ".", "pop", "(", "1", ")", "next_cursor", "=", "next_item", ".", "to_cursor_ref", "(", ")", "'''\n # is this field allowed for sort?\n if field not in self.sort_fields:\n raise ValueError(\"Cannot sort on field '{}'\".format(field))\n '''", "return", "items", ",", "next_cursor" ]

[ "List", "items", "from", "query" ]

[ "def", "matches_glob_list", "(", "path", ",", "glob_list", ")", ":", "for", "glob", "in", "glob_list", ":", "try", ":", "if", "PurePath", "(", "path", ")", ".", "match", "(", "glob", ")", ":", "return", "True", "except", "TypeError", ":", "pass", "return", "False" ]

[ "Given", "a", "list", "of", "glob", "patterns", "returns", "a", "boolean", "indicating", "if", "a", "path", "matches", "any", "glob", "in", "the", "list" ]

[ "def", "file_download_ui", "(", "pid", ",", "record", ",", "_record_file_factory", "=", "None", ",", "*", "*", "kwargs", ")", ":", "_record_file_factory", "=", "_record_file_factory", "or", "record_file_factory", "# Extract file from record.", "fileobj", "=", "_record_file_factory", "(", "pid", ",", "record", ",", "kwargs", ".", "get", "(", "'filename'", ")", ")", "if", "not", "fileobj", ":", "abort", "(", "404", ")", "obj", "=", "fileobj", ".", "obj", "# Check permissions", "ObjectResource", ".", "check_object_permission", "(", "obj", ")", "# Send file.", "return", "ObjectResource", ".", "send_object", "(", "obj", ".", "bucket", ",", "obj", ",", "expected_chksum", "=", "fileobj", ".", "get", "(", "'checksum'", ")", ",", "logger_data", "=", "{", "'bucket_id'", ":", "obj", ".", "bucket_id", ",", "'pid_type'", ":", "pid", ".", "pid_type", ",", "'pid_value'", ":", "pid", ".", "pid_value", ",", "}", ",", "as_attachment", "=", "(", "'download'", "in", "request", ".", "args", ")", ")" ]

[ "File", "download", "view", "for", "a", "given", "record", "." ]

[ "def", "encode_example", "(", "self", ",", "image_or_path_or_fobj", ")", ":", "if", "isinstance", "(", "image_or_path_or_fobj", ",", "np", ".", "ndarray", ")", ":", "encoded_image", "=", "self", ".", "_encode_image", "(", "image_or_path_or_fobj", ")", "elif", "isinstance", "(", "image_or_path_or_fobj", ",", "six", ".", "string_types", ")", ":", "with", "tf", ".", "io", ".", "gfile", ".", "GFile", "(", "image_or_path_or_fobj", ",", "'rb'", ")", "as", "image_f", ":", "encoded_image", "=", "image_f", ".", "read", "(", ")", "else", ":", "encoded_image", "=", "image_or_path_or_fobj", ".", "read", "(", ")", "return", "encoded_image" ]

[ "Convert", "the", "given", "image", "into", "a", "dict", "convertible", "to", "tf", "example", "." ]

[ "def", "qos_map_dscp_cos_mark_to", "(", "self", ",", "*", "*", "kwargs", ")", ":", "config", "=", "ET", ".", "Element", "(", "\"config\"", ")", "qos", "=", "ET", ".", "SubElement", "(", "config", ",", "\"qos\"", ",", "xmlns", "=", "\"urn:brocade.com:mgmt:brocade-qos\"", ")", "map", "=", "ET", ".", "SubElement", "(", "qos", ",", "\"map\"", ")", "dscp_cos", "=", "ET", ".", "SubElement", "(", "map", ",", "\"dscp-cos\"", ")", "dscp_cos_map_name_key", "=", "ET", ".", "SubElement", "(", "dscp_cos", ",", "\"dscp-cos-map-name\"", ")", "dscp_cos_map_name_key", ".", "text", "=", "kwargs", ".", "pop", "(", "'dscp_cos_map_name'", ")", "mark", "=", "ET", ".", "SubElement", "(", "dscp_cos", ",", "\"mark\"", ")", "dscp_in_values_key", "=", "ET", ".", "SubElement", "(", "mark", ",", "\"dscp-in-values\"", ")", "dscp_in_values_key", ".", "text", "=", "kwargs", ".", "pop", "(", "'dscp_in_values'", ")", "to", "=", "ET", ".", "SubElement", "(", "mark", ",", "\"to\"", ")", "to", ".", "text", "=", "kwargs", ".", "pop", "(", "'to'", ")", "callback", "=", "kwargs", ".", "pop", "(", "'callback'", ",", "self", ".", "_callback", ")", "return", "callback", "(", "config", ")" ]

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

[ "def", "get_top_tracks", "(", "self", ",", "limit", "=", "None", ",", "cacheable", "=", "True", ")", ":", "params", "=", "self", ".", "_get_params", "(", ")", "if", "limit", ":", "params", "[", "\"limit\"", "]", "=", "limit", "return", "self", ".", "_get_things", "(", "\"getTopTracks\"", ",", "\"track\"", ",", "Track", ",", "params", ",", "cacheable", ")" ]

[ "Returns", "a", "list", "of", "the", "most", "played", "Tracks", "by", "this", "artist", "." ]

[ "def", "write_object", "(", "ctx", ",", "pin", ",", "management_key", ",", "object_id", ",", "data", ")", ":", "controller", "=", "ctx", ".", "obj", "[", "'controller'", "]", "_ensure_authenticated", "(", "ctx", ",", "controller", ",", "pin", ",", "management_key", ")", "def", "do_write_object", "(", "retry", "=", "True", ")", ":", "try", ":", "controller", ".", "put_data", "(", "object_id", ",", "data", ".", "read", "(", ")", ")", "except", "APDUError", "as", "e", ":", "logger", ".", "debug", "(", "'Failed writing object'", ",", "exc_info", "=", "e", ")", "if", "e", ".", "sw", "==", "SW", ".", "INCORRECT_PARAMETERS", ":", "ctx", ".", "fail", "(", "'Something went wrong, is the object id valid?'", ")", "raise", "do_write_object", "(", ")" ]

[ "Write", "an", "arbitrary", "PIV", "object", "." ]

[ "def", "columns_in_formula", "(", "formula", ")", ":", "if", "formula", "is", "None", ":", "return", "[", "]", "formula", "=", "str_model_expression", "(", "formula", ",", "add_constant", "=", "False", ")", "columns", "=", "[", "]", "tokens", "=", "map", "(", "lambda", "x", ":", "x", ".", "extra", ",", "tz", ".", "remove", "(", "lambda", "x", ":", "x", ".", "extra", "is", "None", ",", "_tokens_from_patsy", "(", "patsy", ".", "parse_formula", ".", "parse_formula", "(", "formula", ")", ")", ")", ")", "for", "tok", "in", "tokens", ":", "# if there are parentheses in the expression we", "# want to drop them and everything outside", "# and start again from the top", "if", "'('", "in", "tok", ":", "start", "=", "tok", ".", "find", "(", "'('", ")", "+", "1", "fin", "=", "tok", ".", "rfind", "(", "')'", ")", "columns", ".", "extend", "(", "columns_in_formula", "(", "tok", "[", "start", ":", "fin", "]", ")", ")", "else", ":", "for", "toknum", ",", "tokval", ",", "_", ",", "_", ",", "_", "in", "generate_tokens", "(", "StringIO", "(", "tok", ")", ".", "readline", ")", ":", "if", "toknum", "==", "NAME", ":", "columns", ".", "append", "(", "tokval", ")", "return", "list", "(", "tz", ".", "unique", "(", "columns", ")", ")" ]

[ "Returns", "the", "names", "of", "all", "the", "columns", "used", "in", "a", "patsy", "formula", "." ]

[ "def", "to_odict", "(", "self", ",", "exclude", "=", "None", ")", ":", "if", "exclude", "is", "None", ":", "exclude", "=", "tuple", "(", ")", "colnames", "=", "[", "c", ".", "name", "for", "c", "in", "self", ".", "__table__", ".", "columns", "if", "c", ".", "name", "not", "in", "exclude", "]", "return", "OrderedDict", "(", "(", "(", "col", ",", "getattr", "(", "self", ",", "col", ")", ")", "for", "col", "in", "colnames", ")", ")" ]

[ "Returns", "an", "OrderedDict", "representation", "of", "the", "SQLalchemy", "table", "row", "." ]

[ "def", "_evolve", "(", "self", ",", "state", ",", "qargs", "=", "None", ")", ":", "# If subsystem evolution we use the SuperOp representation", "if", "qargs", "is", "not", "None", ":", "return", "SuperOp", "(", "self", ")", ".", "_evolve", "(", "state", ",", "qargs", ")", "# Otherwise we compute full evolution directly", "state", "=", "self", ".", "_format_state", "(", "state", ")", "if", "state", ".", "shape", "[", "0", "]", "!=", "self", ".", "_input_dim", ":", "raise", "QiskitError", "(", "\"QuantumChannel input dimension is not equal to state dimension.\"", ")", "if", "state", ".", "ndim", "==", "1", "and", "self", ".", "_data", "[", "1", "]", "is", "None", "and", "len", "(", "self", ".", "_data", "[", "0", "]", ")", "==", "1", ":", "# If we only have a single Kraus operator we can implement unitary-type", "# evolution of a state vector psi -> K[0].psi", "return", "np", ".", "dot", "(", "self", ".", "_data", "[", "0", "]", "[", "0", "]", ",", "state", ")", "# Otherwise we always return a density matrix", "state", "=", "self", ".", "_format_state", "(", "state", ",", "density_matrix", "=", "True", ")", "kraus_l", ",", "kraus_r", "=", "self", ".", "_data", "if", "kraus_r", "is", "None", ":", "kraus_r", "=", "kraus_l", "return", "np", ".", "einsum", "(", "'AiB,BC,AjC->ij'", ",", "kraus_l", ",", "state", ",", "np", ".", "conjugate", "(", "kraus_r", ")", ")" ]

[ "Evolve", "a", "quantum", "state", "by", "the", "QuantumChannel", "." ]

[ "def", "lines", "(", "self", ",", "encoding", "=", "None", ",", "errors", "=", "'strict'", ",", "retain", "=", "True", ")", ":", "if", "encoding", "is", "None", "and", "retain", ":", "f", "=", "self", ".", "open", "(", "'U'", ")", "try", ":", "return", "f", ".", "readlines", "(", ")", "finally", ":", "f", ".", "close", "(", ")", "else", ":", "return", "self", ".", "text", "(", "encoding", ",", "errors", ")", ".", "splitlines", "(", "retain", ")" ]

[ "r", "Open", "this", "file", "read", "all", "lines", "return", "them", "in", "a", "list", "." ]

[ "def", "new_pattern", "(", "self", ",", "id_", ",", "name", ",", "rows", "=", "None", ")", ":", "if", "rows", "is", "None", ":", "rows", "=", "self", ".", "new_row_collection", "(", ")", "return", "self", ".", "_spec", ".", "new_pattern", "(", "id_", ",", "name", ",", "rows", ",", "self", ")" ]

[ "Create", "a", "new", "knitting", "pattern", "." ]

[ "def", "to_bytes", "(", "text", ",", "encoding", "=", "'utf-8'", ")", ":", "if", "not", "text", ":", "return", "text", "if", "not", "isinstance", "(", "text", ",", "bytes_type", ")", ":", "text", "=", "text", ".", "encode", "(", "encoding", ")", "return", "text" ]

[ "Make", "sure", "text", "is", "bytes", "type", "." ]

[ "def", "ajax_recalculate_prices", "(", "self", ")", ":", "# When the option \"Include and display pricing information\" in", "# Bika Setup Accounting tab is not selected", "if", "not", "self", ".", "show_recalculate_prices", "(", ")", ":", "return", "{", "}", "# The sorted records from the request", "records", "=", "self", ".", "get_records", "(", ")", "client", "=", "self", ".", "get_client", "(", ")", "bika_setup", "=", "api", ".", "get_bika_setup", "(", ")", "member_discount", "=", "float", "(", "bika_setup", ".", "getMemberDiscount", "(", ")", ")", "member_discount_applies", "=", "False", "if", "client", ":", "member_discount_applies", "=", "client", ".", "getMemberDiscountApplies", "(", ")", "prices", "=", "{", "}", "for", "n", ",", "record", "in", "enumerate", "(", "records", ")", ":", "ardiscount_amount", "=", "0.00", "arservices_price", "=", "0.00", "arprofiles_price", "=", "0.00", "arprofiles_vat_amount", "=", "0.00", "arservice_vat_amount", "=", "0.00", "services_from_priced_profile", "=", "[", "]", "profile_uids", "=", "record", ".", "get", "(", "\"Profiles_uid\"", ",", "\"\"", ")", ".", "split", "(", "\",\"", ")", "profile_uids", "=", "filter", "(", "lambda", "x", ":", "x", ",", "profile_uids", ")", "profiles", "=", "map", "(", "self", ".", "get_object_by_uid", ",", "profile_uids", ")", "services", "=", "map", "(", "self", ".", "get_object_by_uid", ",", "record", ".", "get", "(", "\"Analyses\"", ",", "[", "]", ")", ")", "# ANALYSIS PROFILES PRICE", "for", "profile", "in", "profiles", ":", "use_profile_price", "=", "profile", ".", "getUseAnalysisProfilePrice", "(", ")", "if", "not", "use_profile_price", ":", "continue", "profile_price", "=", "float", "(", "profile", ".", "getAnalysisProfilePrice", "(", ")", ")", "arprofiles_price", "+=", "profile_price", "arprofiles_vat_amount", "+=", "profile", ".", "getVATAmount", "(", ")", "profile_services", "=", "profile", ".", "getService", "(", ")", "services_from_priced_profile", ".", "extend", "(", "profile_services", ")", "# ANALYSIS SERVICES PRICE", "for", "service", "in", "services", ":", "if", "service", "in", "services_from_priced_profile", ":", "continue", "service_price", "=", "float", "(", "service", ".", "getPrice", "(", ")", ")", "# service_vat = float(service.getVAT())", "service_vat_amount", "=", "float", "(", "service", ".", "getVATAmount", "(", ")", ")", "arservice_vat_amount", "+=", "service_vat_amount", "arservices_price", "+=", "service_price", "base_price", "=", "arservices_price", "+", "arprofiles_price", "# Calculate the member discount if it applies", "if", "member_discount", "and", "member_discount_applies", ":", "logger", ".", "info", "(", "\"Member discount applies with {}%\"", ".", "format", "(", "member_discount", ")", ")", "ardiscount_amount", "=", "base_price", "*", "member_discount", "/", "100", "subtotal", "=", "base_price", "-", "ardiscount_amount", "vat_amount", "=", "arprofiles_vat_amount", "+", "arservice_vat_amount", "total", "=", "subtotal", "+", "vat_amount", "prices", "[", "n", "]", "=", "{", "\"discount\"", ":", "\"{0:.2f}\"", ".", "format", "(", "ardiscount_amount", ")", ",", "\"subtotal\"", ":", "\"{0:.2f}\"", ".", "format", "(", "subtotal", ")", ",", "\"vat\"", ":", "\"{0:.2f}\"", ".", "format", "(", "vat_amount", ")", ",", "\"total\"", ":", "\"{0:.2f}\"", ".", "format", "(", "total", ")", ",", "}", "logger", ".", "info", "(", "\"Prices for AR {}: Discount={discount} \"", "\"VAT={vat} Subtotal={subtotal} total={total}\"", ".", "format", "(", "n", ",", "*", "*", "prices", "[", "n", "]", ")", ")", "return", "prices" ]

[ "Recalculate", "prices", "for", "all", "ARs" ]

[ "def", "set_children", "(", "self", ",", "item", ",", "*", "newchildren", ")", ":", "self", ".", "_visual_drag", ".", "set_children", "(", "item", ",", "*", "newchildren", ")", "ttk", ".", "Treeview", ".", "set_children", "(", "self", ",", "item", ",", "*", "newchildren", ")" ]

[ "Replaces", "item’s", "children", "with", "newchildren", "." ]

[ "def", "export", "(", "self", ",", "output_folder", ")", ":", "if", "not", "os", ".", "path", ".", "exists", "(", "output_folder", ")", ":", "os", ".", "makedirs", "(", "output_folder", ")", "self", ".", "_interact_with_folder", "(", "output_folder", ",", "'w'", ")" ]

[ "Export", "matrices", "as", "*", ".", "npy", "files", "to", "an", "output", "folder", "." ]

[ "def", "copy", "(", "self", ")", ":", "cpy", "=", "copy", ".", "copy", "(", "self", ")", "cpy", ".", "parseAction", "=", "self", ".", "parseAction", "[", ":", "]", "cpy", ".", "ignoreExprs", "=", "self", ".", "ignoreExprs", "[", ":", "]", "if", "self", ".", "copyDefaultWhiteChars", ":", "cpy", ".", "whiteChars", "=", "ParserElement", ".", "DEFAULT_WHITE_CHARS", "return", "cpy" ]

[ "Make", "a", "copy", "of", "this", ":", "class", ":", "ParserElement", ".", "Useful", "for", "defining", "different", "parse", "actions", "for", "the", "same", "parsing", "pattern", "using", "copies", "of", "the", "original", "parse", "element", "." ]

[ "def", "process_tokens", "(", "self", ",", "tokens", ")", ":", "i", "=", "0", "tokens", "=", "list", "(", "tokens", ")", "while", "i", "<", "len", "(", "tokens", ")", ":", "i", ",", "lines_number", ",", "line_type", "=", "get_type", "(", "tokens", ",", "i", ")", "self", ".", "stats", "[", "\"total_lines\"", "]", "+=", "lines_number", "self", ".", "stats", "[", "line_type", "]", "+=", "lines_number" ]

[ "update", "stats" ]

[ "def", "validate", "(", "cls", ",", "full_config", ":", "typing", ".", "Dict", "[", "str", ",", "typing", ".", "Any", "]", ")", "->", "typing", ".", "Dict", "[", "str", ",", "typing", ".", "Any", "]", ":", "if", "cls", ".", "key", "is", "not", "None", ":", "if", "cls", ".", "key", "in", "full_config", ":", "return", "{", "cls", ".", "key", ":", "full_config", "[", "cls", ".", "key", "]", "}", "elif", "cls", ".", "required", ":", "return", "{", "cls", ".", "key", ":", "cls", ".", "default", "}" ]

[ "If", "cls", ".", "key", "is", "not", ":", "obj", ":", "None", "and", "that", "is", "in", "config", "returns", "config", "with", "that", "argument", "." ]

[ "def", "sparse_arrays", "(", "self", ",", "value", ")", ":", "if", "not", "isinstance", "(", "value", ",", "bool", ")", ":", "raise", "TypeError", "(", "'sparse_arrays attribute must be a logical type.'", ")", "self", ".", "_sparse_arrays", "=", "value" ]

[ "Validate", "and", "enable", "spare", "arrays", "." ]

[ "def", "update_metadata_statement", "(", "self", ",", "metadata_statement", ",", "receiver", "=", "''", ",", "federation", "=", "None", ",", "context", "=", "''", ")", ":", "self", ".", "add_sms_spec_to_request", "(", "metadata_statement", ",", "federation", "=", "federation", ",", "context", "=", "context", ")", "self", ".", "add_signing_keys", "(", "metadata_statement", ")", "metadata_statement", "=", "self", ".", "self_sign", "(", "metadata_statement", ",", "receiver", ")", "# These are unprotected here so can as well be removed", "del", "metadata_statement", "[", "'signing_keys'", "]", "return", "metadata_statement" ]

[ "Update", "a", "metadata", "statement", "by", ":", "*", "adding", "signed", "metadata", "statements", "or", "uris", "pointing", "to", "signed", "metadata", "statements", ".", "*", "adding", "the", "entities", "signing", "keys", "*", "create", "metadata", "statements", "one", "per", "signed", "metadata", "statement", "or", "uri", "sign", "these", "and", "add", "them", "to", "the", "metadata", "statement" ]

[ "def", "_get_config_name", "(", ")", ":", "p", "=", "subprocess", ".", "Popen", "(", "'git config --get user.name'", ",", "shell", "=", "True", ",", "stdout", "=", "subprocess", ".", "PIPE", ",", "stderr", "=", "subprocess", ".", "STDOUT", ")", "output", "=", "p", ".", "stdout", ".", "readlines", "(", ")", "return", "_stripslashes", "(", "output", "[", "0", "]", ")" ]

[ "Get", "git", "config", "user", "name" ]

[ "def", "load_uri", "(", "self", ",", "uri", ",", "verbose", ")", ":", "if", "verbose", ":", "printDebug", "(", "\"----------\"", ")", "if", "verbose", ":", "printDebug", "(", "\"Reading: <%s>\"", "%", "uri", ")", "success", "=", "False", "for", "f", "in", "self", ".", "rdf_format_opts", ":", "if", "verbose", ":", "printDebug", "(", "\".. trying rdf serialization: <%s>\"", "%", "f", ")", "try", ":", "self", ".", "rdfgraph", ".", "parse", "(", "uri", ",", "format", "=", "f", ")", "if", "verbose", ":", "printDebug", "(", "\"..... success!\"", ",", "bold", "=", "True", ")", "success", "=", "True", "self", ".", "sources_valid", "+=", "[", "uri", "]", "break", "except", ":", "if", "verbose", ":", "printDebug", "(", "\"..... failed\"", ")", "if", "not", "success", "==", "True", ":", "self", ".", "loading_failed", "(", "self", ".", "rdf_format_opts", ")", "self", ".", "sources_invalid", "+=", "[", "uri", "]" ]

[ ":", "param", "uri", ":", ":", "param", "rdf_format_opts", ":", ":", "param", "verbose", ":", ":", "return", ":" ]

[ "def", "_avg", "(", "value1", ",", "value2", ",", "weight", ")", ":", "if", "value1", "is", "None", ":", "return", "value2", "if", "value2", "is", "None", ":", "return", "value1", "return", "value2", "*", "weight", "+", "value1", "*", "(", "1", "-", "weight", ")" ]

[ "Returns", "the", "weighted", "average", "of", "two", "values", "and", "handles", "the", "case", "where", "one", "value", "is", "None", ".", "If", "both", "values", "are", "None", "None", "is", "returned", "." ]

[ "def", "lru_cache", "(", "maxsize", "=", "100", ",", "typed", "=", "False", ")", ":", "# Users should only access the lru_cache through its public API:", "# cache_info, cache_clear, and f.__wrapped__", "# The internals of the lru_cache are encapsulated for thread safety and", "# to allow the implementation to change (including a possible C version).", "def", "decorating_function", "(", "user_function", ")", ":", "cache", "=", "dict", "(", ")", "stats", "=", "[", "0", ",", "0", "]", "# make statistics updateable non-locally", "HITS", ",", "MISSES", "=", "0", ",", "1", "# names for the stats fields", "kwd_mark", "=", "(", "object", "(", ")", ",", ")", "# separate positional and keyword args", "cache_get", "=", "cache", ".", "get", "# bound method to lookup key or return None", "_len", "=", "len", "# localize the global len() function", "lock", "=", "Lock", "(", ")", "# because linkedlist updates aren't threadsafe", "root", "=", "[", "]", "# root of the circular doubly linked list", "nonlocal_root", "=", "[", "root", "]", "# make updateable non-locally", "root", "[", ":", "]", "=", "[", "root", ",", "root", ",", "None", ",", "None", "]", "# initialize by pointing to self", "PREV", ",", "NEXT", ",", "KEY", ",", "RESULT", "=", "0", ",", "1", ",", "2", ",", "3", "# names for the link fields", "def", "make_key", "(", "args", ",", "kwds", ",", "typed", ",", "tuple", "=", "tuple", ",", "sorted", "=", "sorted", ",", "type", "=", "type", ")", ":", "# helper function to build a cache key from positional and keyword args", "key", "=", "args", "if", "kwds", ":", "sorted_items", "=", "tuple", "(", "sorted", "(", "kwds", ".", "items", "(", ")", ")", ")", "key", "+=", "kwd_mark", "+", "sorted_items", "if", "typed", ":", "key", "+=", "tuple", "(", "type", "(", "v", ")", "for", "v", "in", "args", ")", "if", "kwds", ":", "key", "+=", "tuple", "(", "type", "(", "v", ")", "for", "k", ",", "v", "in", "sorted_items", ")", "return", "key", "if", "maxsize", "==", "0", ":", "def", "wrapper", "(", "*", "args", ",", "*", "*", "kwds", ")", ":", "# no caching, just do a statistics update after a successful call", "result", "=", "user_function", "(", "*", "args", ",", "*", "*", "kwds", ")", "stats", "[", "MISSES", "]", "+=", "1", "return", "result", "elif", "maxsize", "is", "None", ":", "def", "wrapper", "(", "*", "args", ",", "*", "*", "kwds", ")", ":", "# simple caching without ordering or size limit", "key", "=", "make_key", "(", "args", ",", "kwds", ",", "typed", ")", "if", "kwds", "or", "typed", "else", "args", "result", "=", "cache_get", "(", "key", ",", "root", ")", "# root used here as a unique not-found sentinel", "if", "result", "is", "not", "root", ":", "stats", "[", "HITS", "]", "+=", "1", "return", "result", "result", "=", "user_function", "(", "*", "args", ",", "*", "*", "kwds", ")", "cache", "[", "key", "]", "=", "result", "stats", "[", "MISSES", "]", "+=", "1", "return", "result", "else", ":", "def", "wrapper", "(", "*", "args", ",", "*", "*", "kwds", ")", ":", "# size limited caching that tracks accesses by recency", "key", "=", "make_key", "(", "args", ",", "kwds", ",", "typed", ")", "if", "kwds", "or", "typed", "else", "args", "with", "lock", ":", "link", "=", "cache_get", "(", "key", ")", "if", "link", "is", "not", "None", ":", "# record recent use of the key by moving it to the front of the list", "root", ",", "=", "nonlocal_root", "link_prev", ",", "link_next", ",", "key", ",", "result", "=", "link", "link_prev", "[", "NEXT", "]", "=", "link_next", "link_next", "[", "PREV", "]", "=", "link_prev", "last", "=", "root", "[", "PREV", "]", "last", "[", "NEXT", "]", "=", "root", "[", "PREV", "]", "=", "link", "link", "[", "PREV", "]", "=", "last", "link", "[", "NEXT", "]", "=", "root", "stats", "[", "HITS", "]", "+=", "1", "return", "result", "result", "=", "user_function", "(", "*", "args", ",", "*", "*", "kwds", ")", "with", "lock", ":", "root", "=", "nonlocal_root", "[", "0", "]", "if", "_len", "(", "cache", ")", "<", "maxsize", ":", "# put result in a new link at the front of the list", "last", "=", "root", "[", "PREV", "]", "link", "=", "[", "last", ",", "root", ",", "key", ",", "result", "]", "cache", "[", "key", "]", "=", "last", "[", "NEXT", "]", "=", "root", "[", "PREV", "]", "=", "link", "else", ":", "# use root to store the new key and result", "root", "[", "KEY", "]", "=", "key", "root", "[", "RESULT", "]", "=", "result", "cache", "[", "key", "]", "=", "root", "# empty the oldest link and make it the new root", "root", "=", "nonlocal_root", "[", "0", "]", "=", "root", "[", "NEXT", "]", "del", "cache", "[", "root", "[", "KEY", "]", "]", "root", "[", "KEY", "]", "=", "None", "root", "[", "RESULT", "]", "=", "None", "stats", "[", "MISSES", "]", "+=", "1", "return", "result", "def", "cache_info", "(", ")", ":", "\"\"\"Report cache statistics\"\"\"", "with", "lock", ":", "return", "_CacheInfo", "(", "stats", "[", "HITS", "]", ",", "stats", "[", "MISSES", "]", ",", "maxsize", ",", "len", "(", "cache", ")", ")", "def", "cache_clear", "(", ")", ":", "\"\"\"Clear the cache and cache statistics\"\"\"", "with", "lock", ":", "cache", ".", "clear", "(", ")", "root", "=", "nonlocal_root", "[", "0", "]", "root", "[", ":", "]", "=", "[", "root", ",", "root", ",", "None", ",", "None", "]", "stats", "[", ":", "]", "=", "[", "0", ",", "0", "]", "wrapper", ".", "__wrapped__", "=", "user_function", "wrapper", ".", "cache_info", "=", "cache_info", "wrapper", ".", "cache_clear", "=", "cache_clear", "return", "update_wrapper", "(", "wrapper", ",", "user_function", ")", "return", "decorating_function" ]

[ "Least", "-", "recently", "-", "used", "cache", "decorator", "." ]

[ "def", "has_matching_leftmost", "(", "self", ",", "remote_as", ")", ":", "if", "not", "self", ".", "value", "or", "not", "remote_as", ":", "return", "False", "leftmost_seg", "=", "self", ".", "path_seg_list", "[", "0", "]", "if", "leftmost_seg", "and", "leftmost_seg", "[", "0", "]", "==", "remote_as", ":", "return", "True", "return", "False" ]

[ "Check", "if", "leftmost", "AS", "matches", "*", "remote_as", "*", "." ]

[ "def", "clean_dataframe", "(", "df", ",", "is_slugify", "=", "True", ",", "threshold", "=", "50", ",", "rename_cols", "=", "None", ")", ":", "if", "is_slugify", ":", "df", "=", "df", ".", "rename", "(", "columns", "=", "slugify", ")", "df", "=", "df", ".", "dropna", "(", "axis", "=", "1", ",", "how", "=", "'all'", ")", "for", "column", "in", "get_category_cols", "(", "df", ",", "threshold", "=", "threshold", ")", ":", "df", "[", "column", "]", "=", "df", "[", "column", "]", ".", "astype", "(", "'category'", ")", "for", "column", "in", "get_int_cols", "(", "df", ")", ":", "df", "[", "column", "]", "=", "df", "[", "column", "]", ".", "astype", "(", "int", ")", "if", "rename_cols", "is", "not", "None", ":", "df", "=", "df", ".", "rename", "(", "columns", "=", "rename_cols", ")", "return", "df" ]

[ "This", "method", "is", "used", "to", ":", "-", "slugify", "the", "column", "names", "(", "if", "slugify", "is", "set", "to", "True", ")", "-", "convert", "columns", "to", "category", "(", "if", "len", "(", "unique", ")", "<", "threshold", ")", "or", "int", "-", "clean", "the", "dataframe", "and", "rename", "if", "necessary" ]

[ "def", "opt_weights", "(", "self", ")", ":", "return", "pd", ".", "DataFrame", "(", "self", ".", "_xs", ",", "index", "=", "self", ".", "newidx", ",", "columns", "=", "self", ".", "cols", ")" ]

[ "Optimal", "weights", "(", "period", "-", "end", ")", "." ]