Datasets:

sia-precision-education

/

pile_python

like 3

[ "r", "(", "the", "r", "in", "the", "above", "line", "is", "to", "keep", "pylint", "happy", ")", "__", "/", "__", "\\", "<", "-", "compute", "the", "line", "width", "which", "is", "drawable", "between", "2", "circles", ".", "/", "_", "\\", "max_centering_proportion", ":", "0", "touching", "the", "circle1", "1", "|", "|_|", "|", "touching", "the", "circle2", "0", ".", "5", ":", "middle", "between", "the", "2", "circles", "|", "|", "\\", "/", "\\", "__", "/", "basically", "max_centering_proportion", "is", "max_centering_proportion", "/", "nb_lines" ]

[ "def", "get_max_width_for_circles", "(", "self", ",", "rad1", ",", "rad2", ",", "max_centering_proportion", ")", ":", "# radius at the center of the 2 circles", "rmid", "=", "rad2", "-", "(", "rad2", "-", "rad1", ")", "*", "max_centering_proportion", "return", "sin", "(", "acos", "(", "rmid", "/", "rad2", ")", ")", "*", "rad2", "*", "2" ]

[ "Items", "required", "are", "the", "name", "of", "the", "top", "menu", "the", "sub", "items", "and", "the", "type", "." ]

[ "def", "__init__", "(", "self", ",", "name", ":", "str", ",", "sub_items", ":", "list", ",", "type", ":", "str", ")", ":", "self", ".", "name", "=", "name", "self", ".", "sub_items", "=", "sub_items", "self", ".", "type", "=", "type", "self", ".", "counter", "=", "0", "# Create all the necessary lists that will be used later on", "self", ".", "commands", "=", "[", "]", "self", ".", "script_dirs", "=", "[", "]", "self", ".", "funcs", "=", "[", "]", "self", ".", "imports", "=", "[", "]" ]

[ "read", "label", "file", ":", "param", "dir", ":", "path", ":", "return", ":" ]

[ "def", "read_annotation", "(", "base_dir", ",", "label_path", ")", ":", "data", "=", "dict", "(", ")", "images", "=", "[", "]", "bboxes", "=", "[", "]", "labelfile", "=", "open", "(", "label_path", ",", "'r'", ")", "while", "True", ":", "# image path", "imagepath", "=", "labelfile", ".", "readline", "(", ")", ".", "strip", "(", "'\\n'", ")", "if", "not", "imagepath", ":", "break", "imagepath", "=", "base_dir", "+", "'/WIDER_train/images/'", "+", "imagepath", "images", ".", "append", "(", "imagepath", ")", "# face numbers", "nums", "=", "labelfile", ".", "readline", "(", ")", ".", "strip", "(", "'\\n'", ")", "# im = cv2.imread(imagepath)", "# h, w, c = im.shape", "one_image_bboxes", "=", "[", "]", "for", "i", "in", "range", "(", "int", "(", "nums", ")", ")", ":", "# text = ''", "# text = text + imagepath", "bb_info", "=", "labelfile", ".", "readline", "(", ")", ".", "strip", "(", "'\\n'", ")", ".", "split", "(", "' '", ")", "# only need x, y, w, h", "face_box", "=", "[", "float", "(", "bb_info", "[", "i", "]", ")", "for", "i", "in", "range", "(", "4", ")", "]", "# text = text + ' ' + str(face_box[0] / w) + ' ' + str(face_box[1] / h)", "xmin", "=", "face_box", "[", "0", "]", "ymin", "=", "face_box", "[", "1", "]", "xmax", "=", "xmin", "+", "face_box", "[", "2", "]", "ymax", "=", "ymin", "+", "face_box", "[", "3", "]", "# text = text + ' ' + str(xmax / w) + ' ' + str(ymax / h)", "one_image_bboxes", ".", "append", "(", "[", "xmin", ",", "ymin", ",", "xmax", ",", "ymax", "]", ")", "# f.write(text + '\\n')", "bboxes", ".", "append", "(", "one_image_bboxes", ")", "data", "[", "'images'", "]", "=", "images", "#all images", "data", "[", "'bboxes'", "]", "=", "bboxes", "#all image bboxes", "# f.close()", "return", "data" ]

[ "Given", "a", "function", "and", "args", "and", "keyword", "args", "to", "pass", "to", "it", "call", "the", "function", "but", "using", "only", "the", "keyword", "arguments", "which", "it", "accepts", ".", "This", "is", "equivalent", "to", "redefining", "the", "function", "with", "an", "additional", "\\", "*", "\\", "*", "kwargs", "to", "accept", "slop", "keyword", "args", "." ]

[ "def", "filter_kwargs", "(", "_function", ",", "*", "args", ",", "*", "*", "kwargs", ")", ":", "if", "has_kwargs", "(", "_function", ")", ":", "return", "_function", "(", "*", "args", ",", "*", "*", "kwargs", ")", "# Get the list of function arguments", "func_code", "=", "six", ".", "get_function_code", "(", "_function", ")", "function_args", "=", "func_code", ".", "co_varnames", "[", ":", "func_code", ".", "co_argcount", "]", "# Construct a dict of those kwargs which appear in the function", "filtered_kwargs", "=", "{", "}", "for", "kwarg", ",", "value", "in", "list", "(", "kwargs", ".", "items", "(", ")", ")", ":", "if", "kwarg", "in", "function_args", ":", "filtered_kwargs", "[", "kwarg", "]", "=", "value", "# Call the function with the supplied args and the filtered kwarg dict", "return", "_function", "(", "*", "args", ",", "*", "*", "filtered_kwargs", ")" ]

[]

[ "def", "observation", "(", "self", ",", "obs", ")", ":", "return", "np", ".", "array", "(", "obs", ")", ".", "astype", "(", "np", ".", "float32", ")", "/", "255.0" ]

[ "Like", "read", "()", "but", "the", "argument", "must", "be", "a", "file", "-", "like", "object", "." ]

[ "def", "readfp", "(", "self", ",", "fp", ",", "filename", "=", "None", ")", ":", "if", "filename", "is", "None", ":", "try", ":", "filename", "=", "fp", ".", "name", "except", "AttributeError", ":", "filename", "=", "'<???>'", "self", ".", "_read", "(", "fp", ",", "filename", ")" ]

[ "Describes", "a", "method", "." ]

[ "def", "__method_descriptor", "(", "self", ",", "service", ",", "service_name", ",", "method_info", ",", "protorpc_method_name", ",", "protorpc_method_info", ")", ":", "descriptor", "=", "{", "}", "request_message_type", "=", "protorpc_method_info", ".", "remote", ".", "request_type", "(", ")", "request_kind", "=", "self", ".", "__get_request_kind", "(", "method_info", ")", "remote_method", "=", "protorpc_method_info", ".", "remote", "descriptor", "[", "'path'", "]", "=", "method_info", ".", "get_path", "(", "service", ".", "api_info", ")", "descriptor", "[", "'httpMethod'", "]", "=", "method_info", ".", "http_method", "descriptor", "[", "'rosyMethod'", "]", "=", "'%s.%s'", "%", "(", "service_name", ",", "protorpc_method_name", ")", "descriptor", "[", "'request'", "]", "=", "self", ".", "__request_message_descriptor", "(", "request_kind", ",", "request_message_type", ",", "method_info", ".", "method_id", "(", "service", ".", "api_info", ")", ",", "descriptor", "[", "'path'", "]", ")", "descriptor", "[", "'response'", "]", "=", "self", ".", "__response_message_descriptor", "(", "remote_method", ".", "response_type", "(", ")", ",", "method_info", ".", "method_id", "(", "service", ".", "api_info", ")", ",", "method_info", ".", "cache_control", ")", "scopes", "=", "(", "method_info", ".", "scopes", "if", "method_info", ".", "scopes", "is", "not", "None", "else", "service", ".", "api_info", ".", "scopes", ")", "if", "scopes", ":", "descriptor", "[", "'scopes'", "]", "=", "scopes", "audiences", "=", "(", "method_info", ".", "audiences", "if", "method_info", ".", "audiences", "is", "not", "None", "else", "service", ".", "api_info", ".", "audiences", ")", "if", "audiences", ":", "descriptor", "[", "'audiences'", "]", "=", "audiences", "allowed_client_ids", "=", "(", "method_info", ".", "allowed_client_ids", "if", "method_info", ".", "allowed_client_ids", "is", "not", "None", "else", "service", ".", "api_info", ".", "allowed_client_ids", ")", "if", "allowed_client_ids", ":", "descriptor", "[", "'clientIds'", "]", "=", "allowed_client_ids", "if", "remote_method", ".", "method", ".", "__doc__", ":", "descriptor", "[", "'description'", "]", "=", "remote_method", ".", "method", ".", "__doc__", "return", "descriptor" ]

[ "pull", "changes", "for", "the", "specified", "remote", "(", "defaults", "to", "origin", ")", "." ]

[ "def", "pull", "(", "self", ",", "remote_name", "=", "\"origin\"", ",", "branch", "=", "\"master\"", ",", "force", "=", "False", ")", ":", "for", "remote", "in", "self", ".", "remotes", ":", "if", "remote", ".", "name", "==", "remote_name", ":", "remote", ".", "fetch", "(", ")", "remote_master_id", "=", "self", ".", "lookup_reference", "(", "\"refs/remotes/origin/%s\"", "%", "branch", ")", ".", "target", "if", "force", ":", "repo_branch", "=", "self", ".", "lookup_reference", "(", "\"refs/heads/%s\"", "%", "branch", ")", "repo_branch", ".", "set_target", "(", "remote_master_id", ")", "merge_result", ",", "_", "=", "self", ".", "merge_analysis", "(", "remote_master_id", ")", "# Up to date, do nothing", "if", "merge_result", "&", "pygit2", ".", "GIT_MERGE_ANALYSIS_UP_TO_DATE", ":", "return", "# We can just fastforward", "elif", "merge_result", "&", "pygit2", ".", "GIT_MERGE_ANALYSIS_FASTFORWARD", ":", "self", ".", "checkout_tree", "(", "self", ".", "get", "(", "remote_master_id", ")", ")", "master_ref", "=", "self", ".", "lookup_reference", "(", "\"refs/heads/%s\"", "%", "branch", ")", "master_ref", ".", "set_target", "(", "remote_master_id", ")", "self", ".", "head", ".", "set_target", "(", "remote_master_id", ")", "elif", "merge_result", "&", "pygit2", ".", "GIT_MERGE_ANALYSIS_NORMAL", ":", "raise", "pagure", ".", "exceptions", ".", "GitConflictsException", "(", "\"Pulling remote changes leads to a conflict\"", ")", "else", ":", "_log", ".", "debug", "(", "\"Unexpected merge result: %s\"", "%", "(", "pygit2", ".", "GIT_MERGE_ANALYSIS_NORMAL", ")", ")", "raise", "AssertionError", "(", "\"Unknown merge analysis result\"", ")" ]

[ "Restricts", "the", "alerts", "that", "this", "query", "is", "performed", "on", "to", "the", "specified", "policy", "names", "." ]

[ "def", "set_policy_names", "(", "self", ",", "policy_names", ")", ":", "if", "not", "all", "(", "isinstance", "(", "n", ",", "str", ")", "for", "n", "in", "policy_names", ")", ":", "raise", "ApiError", "(", "\"One or more invalid policy names\"", ")", "self", ".", "_update_criteria", "(", "\"policy_name\"", ",", "policy_names", ")", "return", "self" ]

[]

[ "def", "xiao_gimbutas_11", "(", ")", ":", "return", "_read", "(", "this_dir", "/", "\"xg11.json\"", ",", "source", ")" ]

[ "Changes", "some", "of", "the", "settings", "for", "the", "Spin", "Element", ".", "Must", "call", "Window", ".", "Read", "or", "Window", ".", "Finalize", "prior", "Note", "that", "the", "state", "can", "be", "in", "3", "states", "only", "....", "enabled", "disabled", "readonly", "even", "though", "more", "combinations", "are", "available", ".", "The", "easy", "way", "to", "remember", "is", "that", "if", "you", "change", "the", "readonly", "parameter", "then", "you", "are", "enabling", "the", "element", ".", "Changes", "will", "not", "be", "visible", "in", "your", "window", "until", "you", "call", "window", ".", "read", "or", "window", ".", "refresh", ".", ":", "param", "value", ":", "set", "the", "current", "value", "from", "list", "of", "choices", ":", "type", "value", ":", "(", "Any", ")", ":", "param", "values", ":", "set", "available", "choices", ":", "type", "values", ":", "List", "[", "Any", "]", ":", "param", "disabled", ":", "disable", ".", "Note", "disabled", "and", "readonly", "cannot", "be", "mixed", ".", "It", "must", "be", "one", "OR", "the", "other", ":", "type", "disabled", ":", "(", "bool", ")", ":", "param", "readonly", ":", "make", "element", "readonly", ".", "Note", "disabled", "and", "readonly", "cannot", "be", "mixed", ".", "It", "must", "be", "one", "OR", "the", "other", ":", "type", "readonly", ":", "(", "bool", ")", ":", "param", "visible", ":", "control", "visibility", "of", "element", ":", "type", "visible", ":", "(", "bool", ")" ]

[ "def", "update", "(", "self", ",", "value", "=", "None", ",", "values", "=", "None", ",", "disabled", "=", "None", ",", "readonly", "=", "None", ",", "visible", "=", "None", ")", ":", "if", "not", "self", ".", "_widget_was_created", "(", ")", ":", "# if widget hasn't been created yet, then don't allow", "return", "if", "values", "!=", "None", ":", "old_value", "=", "self", ".", "TKStringVar", ".", "get", "(", ")", "self", ".", "Values", "=", "values", "self", ".", "TKSpinBox", ".", "configure", "(", "values", "=", "values", ")", "self", ".", "TKStringVar", ".", "set", "(", "old_value", ")", "if", "value", "is", "not", "None", ":", "try", ":", "self", ".", "TKStringVar", ".", "set", "(", "value", ")", "self", ".", "DefaultValue", "=", "value", "except", ":", "pass", "if", "readonly", "is", "True", ":", "self", ".", "Readonly", "=", "True", "self", ".", "TKSpinBox", "[", "'state'", "]", "=", "'readonly'", "elif", "readonly", "is", "False", ":", "self", ".", "Readonly", "=", "False", "self", ".", "TKSpinBox", "[", "'state'", "]", "=", "'normal'", "if", "disabled", "is", "True", ":", "self", ".", "TKSpinBox", "[", "'state'", "]", "=", "'disable'", "elif", "disabled", "is", "False", ":", "if", "self", ".", "Readonly", ":", "self", ".", "TKSpinBox", "[", "'state'", "]", "=", "'readonly'", "else", ":", "self", ".", "TKSpinBox", "[", "'state'", "]", "=", "'normal'", "if", "visible", "is", "False", ":", "self", ".", "TKSpinBox", ".", "pack_forget", "(", ")", "elif", "visible", "is", "True", ":", "self", ".", "TKSpinBox", ".", "pack", "(", "padx", "=", "self", ".", "pad_used", "[", "0", "]", ",", "pady", "=", "self", ".", "pad_used", "[", "1", "]", ")", "if", "visible", "is", "not", "None", ":", "self", ".", "_visible", "=", "visible" ]

[ ":", "param", "contours", ":", "[[", "x1", "y1", "]", "[", "x2", "y2", "]", "...", "[", "xn", "yn", "]]", ":", "param", "file_path", ":", "target", "file", "path" ]

[ "def", "write_to_file", "(", "contours", ",", "file_path", ")", ":", "# according to total-text evaluation method, output file shoud be formatted to: y0,x0, ..... yn,xn", "with", "open", "(", "file_path", ",", "'w'", ")", "as", "f", ":", "for", "cont", "in", "contours", ":", "cont", "=", "np", ".", "stack", "(", "[", "cont", "[", ":", ",", "1", "]", ",", "cont", "[", ":", ",", "0", "]", "]", ",", "1", ")", "cont", "=", "cont", ".", "flatten", "(", ")", ".", "astype", "(", "str", ")", ".", "tolist", "(", ")", "cont", "=", "','", ".", "join", "(", "cont", ")", "f", ".", "write", "(", "cont", "+", "'\\n'", ")" ]

[ "Returns", "a", "preprocessed", "image" ]

[ "def", "pipeline", "(", "image", ",", "new_HW", "=", "(", "80", ",", "80", ")", ",", "height_range", "=", "(", "35", ",", "193", ")", ",", "bg", "=", "(", "144", ",", "72", ",", "17", ")", ")", ":", "image", "=", "crop_image", "(", "image", ",", "height_range", ")", "image", "=", "resize_image", "(", "image", ",", "new_HW", ")", "image", "=", "kill_background_grayscale", "(", "image", ",", "bg", ")", "image", "=", "np", ".", "expand_dims", "(", "image", ",", "axis", "=", "2", ")", "return", "image" ]

[ "Build", "metrics", "for", "MINOR_ALARM_", "*", "and", "MAJOR_ALARM_", "*", "notifications", "." ]

[ "def", "__parse_minor_major_alarm", "(", "self", ",", "msg", ")", ":", "error", "=", "msg", "[", "'error'", "]", "if", "error", "not", "in", "self", ".", "metrics", ":", "self", ".", "metrics", "[", "error", "]", "=", "Counter", "(", "'napalm_logs_{error}'", ".", "format", "(", "error", "=", "error", ".", "lower", "(", ")", ")", ",", "'Counter for {error} notifications'", ".", "format", "(", "error", "=", "error", ")", ",", "[", "'host'", ",", "'alarm_reason'", "]", ",", ")", "severity", "=", "error", ".", "split", "(", "'_'", ")", "[", "0", "]", ".", "lower", "(", ")", "alarm_state_metric", "=", "'{}_alarm_state'", ".", "format", "(", "severity", ")", "if", "alarm_state_metric", "not", "in", "self", ".", "metrics", ":", "self", ".", "metrics", "[", "alarm_state_metric", "]", "=", "Gauge", "(", "'napalm_logs_{}'", ".", "format", "(", "alarm_state_metric", ")", ",", "'State of the {} system alarm. 1=SET, 0=CLEARED'", ".", "format", "(", "severity", ")", ",", "[", "'host'", ",", "'alarm_reason'", "]", ",", ")", "labels", "=", "{", "'host'", ":", "msg", "[", "'host'", "]", ",", "'alarm_reason'", ":", "msg", "[", "'yang_message'", "]", "[", "'alarms'", "]", "[", "'alarm'", "]", "[", "'additional-text'", "]", ",", "}", "self", ".", "metrics", "[", "error", "]", ".", "labels", "(", "*", "*", "labels", ")", ".", "inc", "(", ")", "state", "=", "1", "if", "error", "==", "'{}_ALARM_SET'", ".", "format", "(", "severity", ".", "upper", "(", ")", ")", "else", "0", "self", ".", "metrics", "[", "alarm_state_metric", "]", ".", "labels", "(", "*", "*", "labels", ")", ".", "set", "(", "state", ")" ]

[ "The", "profiles", "available", "to", "the", "session", "credentials" ]

[ "def", "available_profiles", "(", "self", ")", ":", "return", "self", ".", "_session", ".", "available_profiles" ]

[ "Arguments", ":" ]

[ "def", "__init__", "(", "self", ",", "renaming", ",", "next", "=", "None", ",", "name", "=", "None", ")", ":", "Step", ".", "__init__", "(", "self", ",", "worker", "=", "None", ",", "next", "=", "next", ",", "name", "=", "name", ")", "self", ".", "renaming", "=", "renaming" ]

[ ":", "returns", ":", "The", "annotation", "provided", "for", "the", "call", ":", "rtype", ":", "unicode" ]

[ "def", "annotation", "(", "self", ")", ":", "return", "self", ".", "_properties", "[", "'annotation'", "]" ]

[ "Sample", "initial", "states", "by", "taking", "random", "number", "of", "no", "-", "ops", "on", "reset", ".", "No", "-", "op", "is", "assumed", "to", "be", "action", "0", "." ]

[ "def", "__init__", "(", "self", ",", "env", ",", "noop_max", "=", "30", ")", ":", "gym", ".", "Wrapper", ".", "__init__", "(", "self", ",", "env", ")", "self", ".", "noop_max", "=", "noop_max", "self", ".", "override_num_noops", "=", "None", "self", ".", "noop_action", "=", "0", "assert", "env", ".", "unwrapped", ".", "get_action_meanings", "(", ")", "[", "0", "]", "==", "'NOOP'" ]

[ "Requests", "uses", "this", "method", "internally", "to", "get", "cookie", "values", ".", "Takes", "as", "args", "name", "and", "optional", "domain", "and", "path", ".", "Returns", "a", "cookie", ".", "value", ".", "If", "there", "are", "conflicting", "cookies", "_find", "arbitrarily", "chooses", "one", ".", "See", "_find_no_duplicates", "if", "you", "want", "an", "exception", "thrown", "if", "there", "are", "conflicting", "cookies", "." ]

[ "def", "_find", "(", "self", ",", "name", ",", "domain", "=", "None", ",", "path", "=", "None", ")", ":", "for", "cookie", "in", "iter", "(", "self", ")", ":", "if", "cookie", ".", "name", "==", "name", ":", "if", "domain", "is", "None", "or", "cookie", ".", "domain", "==", "domain", ":", "if", "path", "is", "None", "or", "cookie", ".", "path", "==", "path", ":", "return", "cookie", ".", "value", "raise", "KeyError", "(", "'name=%r, domain=%r, path=%r'", "%", "(", "name", ",", "domain", ",", "path", ")", ")" ]

[]

[ "def", "try_out", "(", ")", ":", "import", "gourmet", ".", "recipeManager", "rb", "=", "RecipeBrowser", "(", "gourmet", ".", "recipeManager", ".", "get_recipe_manager", "(", ")", ")", "vb", "=", "Gtk", ".", "VBox", "(", ")", "vb", ".", "pack_start", "(", "rb", ",", "True", ",", "True", ",", "0", ")", "rb", ".", "show", "(", ")", "w", "=", "Gtk", ".", "Window", "(", ")", "w", ".", "add", "(", "vb", ")", "w", ".", "show", "(", ")", "vb", ".", "show", "(", ")", "w", ".", "set_size_request", "(", "800", ",", "500", ")", "w", ".", "connect", "(", "'delete-event'", ",", "Gtk", ".", "main_quit", ")", "Gtk", ".", "main", "(", ")" ]

[ "plot", "the", "discriminator", "loss", "values", "and", "save", "the", "plot", "if", "required", ":", "param", "loss_vals", ":", "(", "Variable", "Arg", ")", "numpy", "array", "or", "Sequence", "like", "for", "plotting", "values", ":", "param", "plot_name", ":", "Name", "of", "the", "plot", ":", "param", "fig_size", ":", "size", "of", "the", "generated", "figure", "(", "column_width", "row_width", ")", ":", "param", "save_path", ":", "path", "to", "save", "the", "figure", ":", "param", "legends", ":", "list", "containing", "labels", "for", "loss", "plots", "legends", "len", "(", "legends", ")", "==", "len", "(", "loss_vals", ")", ":", "return", ":" ]

[ "def", "plot_loss", "(", "*", "loss_vals", ",", "plot_name", "=", "\"Loss plot\"", ",", "fig_size", "=", "(", "17", ",", "7", ")", ",", "save_path", "=", "None", ",", "legends", "=", "(", "\"discriminator\"", ",", "\"bottleneck\"", ",", "\"generator\"", ")", ")", ":", "assert", "len", "(", "loss_vals", ")", "==", "len", "(", "legends", ")", ",", "\"Not enough labels for legends\"", "plt", ".", "figure", "(", "figsize", "=", "fig_size", ")", ".", "suptitle", "(", "plot_name", ")", "plt", ".", "grid", "(", "True", ",", "which", "=", "\"both\"", ")", "plt", ".", "ylabel", "(", "\"loss value\"", ")", "plt", ".", "xlabel", "(", "\"spaced iterations\"", ")", "plt", ".", "axhline", "(", "y", "=", "0", ",", "color", "=", "'k'", ")", "plt", ".", "axvline", "(", "x", "=", "0", ",", "color", "=", "'k'", ")", "# plot all the provided loss values in a single plot", "plts", "=", "[", "]", "for", "loss_val", "in", "loss_vals", ":", "plts", ".", "append", "(", "plt", ".", "plot", "(", "loss_val", ")", "[", "0", "]", ")", "plt", ".", "legend", "(", "plts", ",", "legends", ",", "loc", "=", "\"upper right\"", ",", "fontsize", "=", "16", ")", "if", "save_path", "is", "not", "None", ":", "plt", ".", "savefig", "(", "save_path", ")" ]

[ "The", "internal", "ssl", ".", "SSLObject", "instance", "." ]

[ "def", "ssl_object", "(", "self", ")", ":", "return", "self", ".", "_sslobj" ]

[ "Sets", "the", "time", "zone", "for", "the", "current", "thread", "." ]

[ "def", "activate", "(", "timezone", ")", ":", "if", "isinstance", "(", "timezone", ",", "tzinfo", ")", ":", "_active", ".", "value", "=", "timezone", "elif", "isinstance", "(", "timezone", ",", "six", ".", "string_types", ")", "and", "pytz", "is", "not", "None", ":", "_active", ".", "value", "=", "pytz", ".", "timezone", "(", "timezone", ")", "else", ":", "raise", "ValueError", "(", "\"Invalid timezone: %r\"", "%", "timezone", ")" ]

[ "Return", "the", "list", "of", "all", "file", "or", "dir", "objects", "in", "the", "directory", "." ]

[ "def", "list_directory_content", "(", "directory", ",", "element_type", "=", "\"file\"", ")", ":", "filtr", "=", "os", ".", "path", ".", "isfile", "if", "(", "element_type", "==", "\"file\"", ")", "else", "os", ".", "path", ".", "isdir", "path", "=", "directory", ".", "_path", "return", "(", "[", "]", "if", "not", "os", ".", "path", ".", "exists", "(", "path", ")", "else", "[", "name", "for", "name", "in", "os", ".", "listdir", "(", "path", ")", "if", "filtr", "(", "os", ".", "path", ".", "join", "(", "path", ",", "name", ")", ")", "]", ")" ]

[ "创建表格、插入数据" ]

[ "def", "create_db", "(", ")", ":", "# Recreate database each time for demo", "web_db", ".", "drop_all", "(", ")", "web_db", ".", "create_all", "(", ")" ]

[ "coordinate", "-", "wise", "scaling" ]

[ "def", "__mul__", "(", "self", ",", "other", ")", ":", "return", "Surface", "(", "v", "=", "self", ".", "_v", "*", "other", ",", "f", "=", "self", ".", "faces", ",", "check", "=", "False", ")" ]

[ "next", "(", "iterator", "[", "default", "]", ")" ]

[ "def", "newnext", "(", "iterator", ",", "default", "=", "_SENTINEL", ")", ":", "# args = []", "# if default is not _SENTINEL:", "# args.append(default)", "try", ":", "try", ":", "return", "iterator", ".", "__next__", "(", ")", "except", "AttributeError", ":", "try", ":", "return", "iterator", ".", "next", "(", ")", "except", "AttributeError", ":", "raise", "TypeError", "(", "\"'{0}' object is not an iterator\"", ".", "format", "(", "iterator", ".", "__class__", ".", "__name__", ")", ")", "except", "StopIteration", "as", "e", ":", "if", "default", "is", "_SENTINEL", ":", "raise", "e", "else", ":", "return", "default" ]

[ "Inception", "V4", "Model", "for", "Keras" ]

[ "def", "inception_v4_model", "(", "img_rows", ",", "img_cols", ",", "color_type", "=", "1", ",", "num_classeses", "=", "None", ",", "dropout_keep_prob", "=", "0.2", ")", ":", "# Input Shape is 299 x 299 x 3 (tf) or 3 x 299 x 299 (th)", "if", "K", ".", "image_dim_ordering", "(", ")", "==", "'th'", ":", "inputs", "=", "Input", "(", "(", "3", ",", "299", ",", "299", ")", ")", "else", ":", "inputs", "=", "Input", "(", "(", "299", ",", "299", ",", "3", ")", ")", "# Make inception base", "net", "=", "inception_v4_base", "(", "inputs", ")", "# Final pooling and prediction", "# 8 x 8 x 1536", "net_old", "=", "AveragePooling2D", "(", "(", "8", ",", "8", ")", ",", "border_mode", "=", "'valid'", ")", "(", "net", ")", "# 1 x 1 x 1536", "net_old", "=", "Dropout", "(", "dropout_keep_prob", ")", "(", "net_old", ")", "net_old", "=", "Flatten", "(", ")", "(", "net_old", ")", "# 1536", "predictions", "=", "Dense", "(", "output_dim", "=", "1001", ",", "activation", "=", "'softmax'", ")", "(", "net_old", ")", "model", "=", "Model", "(", "inputs", ",", "predictions", ",", "name", "=", "'inception_v4'", ")", "if", "K", ".", "image_dim_ordering", "(", ")", "==", "'th'", ":", "# Use pre-trained weights for Theano backend", "weights_path", "=", "'imagenet_models/inception-v4_weights_th_dim_ordering_th_kernels.h5'", "else", ":", "# Use pre-trained weights for Tensorflow backend", "weights_path", "=", "'imagenet_models/inception-v4_weights_tf_dim_ordering_tf_kernels.h5'", "model", ".", "load_weights", "(", "weights_path", ",", "by_name", "=", "True", ")", "# Truncate and replace softmax layer for transfer learning", "# Cannot use model.layers.pop() since model is not of Sequential() type", "# The method below works since pre-trained weights are stored in layers but not in the model", "net_ft", "=", "AveragePooling2D", "(", "(", "8", ",", "8", ")", ",", "border_mode", "=", "'valid'", ")", "(", "net", ")", "net_ft", "=", "Dropout", "(", "dropout_keep_prob", ")", "(", "net_ft", ")", "net_ft", "=", "Flatten", "(", ")", "(", "net_ft", ")", "predictions_ft", "=", "Dense", "(", "output_dim", "=", "num_classes", ",", "activation", "=", "'softmax'", ")", "(", "net_ft", ")", "model", "=", "Model", "(", "inputs", ",", "predictions_ft", ",", "name", "=", "'inception_v4'", ")", "# Learning rate is changed to 0.001", "sgd", "=", "SGD", "(", "lr", "=", "1e-3", ",", "decay", "=", "1e-6", ",", "momentum", "=", "0.9", ",", "nesterov", "=", "True", ")", "model", ".", "compile", "(", "optimizer", "=", "sgd", ",", "loss", "=", "'categorical_crossentropy'", ",", "metrics", "=", "[", "'accuracy'", "]", ")", "return", "model" ]

[ "r", "Computes", "several", "derivatives", "of", "the", "auxiliary", "function", "of", "Riemann", "R", "(", "s", ")", "." ]

[ "def", "Rzeta_set", "(", "ctx", ",", "s", ",", "derivatives", "=", "[", "0", "]", ")", ":", "der", "=", "max", "(", "derivatives", ")", "# First we take the value of ctx.prec", "# During the computation we will change ctx.prec, and finally we will", "# restaurate the initial value", "wpinitial", "=", "ctx", ".", "prec", "# Take the real and imaginary part of s", "t", "=", "ctx", ".", "_im", "(", "s", ")", "sigma", "=", "ctx", ".", "_re", "(", "s", ")", "# Now compute several parameter that appear on the program", "ctx", ".", "prec", "=", "15", "a", "=", "ctx", ".", "sqrt", "(", "t", "/", "(", "2", "*", "ctx", ".", "pi", ")", ")", "# Careful", "asigma", "=", "ctx", ".", "power", "(", "a", ",", "sigma", ")", "# Careful", "# We need a simple bound A1 < asigma (see II Section 3.1 and 3.3)", "A1", "=", "ctx", ".", "power", "(", "2", ",", "ctx", ".", "mag", "(", "asigma", ")", "-", "1", ")", "# We compute various epsilon's (see II end of Section 3.1)", "eps", "=", "ctx", ".", "power", "(", "2", ",", "-", "wpinitial", ")", "eps1", "=", "eps", "/", "6.", "eps2", "=", "eps", "*", "A1", "/", "3.", "# COMPUTING SOME COEFFICIENTS THAT DEPENDS", "# ON sigma", "# constant b and c (see I Theorem 2 formula (26) )", "# coefficients A and B1 (see I Section 6.1 equation (50))", "# here we not need high precision", "ctx", ".", "prec", "=", "15", "if", "sigma", ">", "0", ":", "b", "=", "2.", "c", "=", "math", ".", "pow", "(", "9", ",", "sigma", ")", "/", "4.44288", "# 4.44288 =(math.sqrt(2)*math.pi)", "A", "=", "math", ".", "pow", "(", "9", ",", "sigma", ")", "B1", "=", "1", "else", ":", "b", "=", "2.25158", "# math.sqrt( (3-2* math.log(2))*math.pi )", "c", "=", "math", ".", "pow", "(", "2", ",", "-", "sigma", ")", "/", "4.44288", "A", "=", "math", ".", "pow", "(", "2", ",", "-", "sigma", ")", "B1", "=", "1.10789", "# = 2*sqrt(1-log(2))", "# COMPUTING L THE NUMBER OF TERMS NEEDED IN THE RIEMANN-SIEGEL", "# CORRECTION", "# See II Section 3.2", "ctx", ".", "prec", "=", "15", "L", "=", "1", "while", "3", "*", "c", "*", "ctx", ".", "gamma", "(", "L", "*", "0.5", ")", "*", "ctx", ".", "power", "(", "b", "*", "a", ",", "-", "L", ")", ">=", "eps2", ":", "L", "=", "L", "+", "1", "L", "=", "max", "(", "2", ",", "L", ")", "# The number L has to satify some conditions.", "# If not RS can not compute Rzeta(s) with the prescribed precision", "# (see II, Section 3.2 condition (20) ) and", "# (II, Section 3.3 condition (22) ). Also we have added", "# an additional technical condition in Section 3.17 Proposition 17", "if", "(", "(", "3", "*", "L", ">=", "2", "*", "a", "*", "a", "/", "25.", ")", "or", "(", "3", "*", "L", "+", "2", "+", "sigma", "<", "0", ")", "or", "(", "abs", "(", "sigma", ")", ">", "a", "/", "2.", ")", ")", ":", "#print 'Error Riemann-Siegel can not compute with such precision'", "ctx", ".", "prec", "=", "wpinitial", "raise", "NotImplementedError", "(", "\"Riemann-Siegel can not compute with such precision\"", ")", "# INITIALIZATION (CONTINUATION)", "#", "# eps3 is the constant defined on (II, Section 3.5 equation (27) )", "# each term of the RS correction must be computed with error <= eps3", "eps3", "=", "eps2", "/", "(", "4", "*", "L", ")", "# eps4 is defined on (II Section 3.6 equation (30) )", "# each component of the formula (II Section 3.6 equation (29) )", "# must be computed with error <= eps4", "eps4", "=", "eps3", "/", "(", "3", "*", "L", ")", "# COMPUTING M. NUMBER OF DERIVATIVES Fp[m] TO COMPUTE", "M", "=", "aux_M_Fp", "(", "ctx", ",", "A", ",", "eps4", ",", "a", ",", "B1", ",", "L", ")", "Fp", "=", "{", "}", "for", "n", "in", "range", "(", "M", ",", "3", "*", "L", "-", "2", ")", ":", "Fp", "[", "n", "]", "=", "0", "# But I have not seen an instance of M != 3*L-3", "#", "# DETERMINATION OF J THE NUMBER OF TERMS NEEDED", "# IN THE TAYLOR SERIES OF F.", "# See II Section 3.11 equation (49))", "h1", "=", "eps4", "/", "(", "632", "*", "A", ")", "h2", "=", "ctx", ".", "pi", "*", "ctx", ".", "pi", "*", "B1", "*", "a", "*", "ctx", ".", "sqrt", "(", "3", ")", "*", "math", ".", "e", "*", "math", ".", "e", "h2", "=", "h1", "*", "ctx", ".", "power", "(", "(", "h2", "/", "M", "**", "2", ")", ",", "(", "M", "-", "1", ")", "/", "3", ")", "/", "M", "h3", "=", "min", "(", "h1", ",", "h2", ")", "J", "=", "12", "jvalue", "=", "(", "2", "*", "ctx", ".", "pi", ")", "**", "J", "/", "ctx", ".", "gamma", "(", "J", "+", "1", ")", "while", "jvalue", ">", "h3", ":", "J", "=", "J", "+", "1", "jvalue", "=", "(", "2", "*", "ctx", ".", "pi", ")", "*", "jvalue", "/", "J", "# COMPUTING eps5[m] for 1 <= m <= 21", "# See II Section 10 equation (43)", "eps5", "=", "{", "}", "foreps5", "=", "math", ".", "pi", "*", "math", ".", "pi", "*", "B1", "*", "a", "for", "m", "in", "range", "(", "0", ",", "22", ")", ":", "aux1", "=", "math", ".", "pow", "(", "foreps5", ",", "m", "/", "3", ")", "/", "(", "316.", "*", "A", ")", "aux2", "=", "ctx", ".", "gamma", "(", "m", "+", "1", ")", "/", "ctx", ".", "gamma", "(", "m", "/", "3.0", "+", "0.5", ")", "aux2", "=", "math", ".", "sqrt", "(", "aux2", ")", "eps5", "[", "m", "]", "=", "aux1", "*", "aux2", "*", "eps4", "# COMPUTING wpfp", "# See II Section 3.13 equation (59)", "twenty", "=", "min", "(", "3", "*", "L", "-", "3", ",", "21", ")", "+", "1", "aux", "=", "6812", "*", "J", "wpfp", "=", "ctx", ".", "mag", "(", "44", "*", "J", ")", "for", "m", "in", "range", "(", "0", ",", "twenty", ")", ":", "wpfp", "=", "max", "(", "wpfp", ",", "ctx", ".", "mag", "(", "aux", "*", "ctx", ".", "gamma", "(", "m", "+", "1", ")", "/", "eps5", "[", "m", "]", ")", ")", "# COMPUTING N AND p", "# See II Section", "ctx", ".", "prec", "=", "wpfp", "+", "ctx", ".", "mag", "(", "t", ")", "+", "20", "a", "=", "ctx", ".", "sqrt", "(", "t", "/", "(", "2", "*", "ctx", ".", "pi", ")", ")", "N", "=", "ctx", ".", "floor", "(", "a", ")", "p", "=", "1", "-", "2", "*", "(", "a", "-", "N", ")", "# now we get a rounded version of p to the precision wpfp", "# this possibly is not necessary", "num", "=", "ctx", ".", "floor", "(", "p", "*", "(", "ctx", ".", "mpf", "(", "2", ")", "**", "wpfp", ")", ")", "difference", "=", "p", "*", "(", "ctx", ".", "mpf", "(", "2", ")", "**", "wpfp", ")", "-", "num", "if", "difference", "<", "0.5", ":", "num", "=", "num", "else", ":", "num", "=", "num", "+", "1", "p", "=", "ctx", ".", "convert", "(", "num", "*", "(", "ctx", ".", "mpf", "(", "2", ")", "**", "(", "-", "wpfp", ")", ")", ")", "# COMPUTING THE COEFFICIENTS c[n] = cc[n]", "# We shall use the notation cc[n], since there is", "# a constant that is called c", "# See II Section 3.14", "# We compute the coefficients and also save then in a", "# cache. The bulk of the computation is passed to", "# the function coef()", "#", "# eps6 is defined in II Section 3.13 equation (58)", "eps6", "=", "ctx", ".", "power", "(", "2", "*", "ctx", ".", "pi", ",", "J", ")", "/", "(", "ctx", ".", "gamma", "(", "J", "+", "1", ")", "*", "3", "*", "J", ")", "# Now we compute the coefficients", "cc", "=", "{", "}", "cont", "=", "{", "}", "cont", ",", "pipowers", "=", "coef", "(", "ctx", ",", "J", ",", "eps6", ")", "cc", "=", "cont", ".", "copy", "(", ")", "# we need a copy since we have", "Fp", "=", "{", "}", "for", "n", "in", "range", "(", "M", ",", "3", "*", "L", "-", "2", ")", ":", "Fp", "[", "n", "]", "=", "0", "ctx", ".", "prec", "=", "wpfp", "for", "m", "in", "range", "(", "0", ",", "M", "+", "1", ")", ":", "sumP", "=", "0", "for", "k", "in", "range", "(", "2", "*", "J", "-", "m", "-", "1", ",", "-", "1", ",", "-", "1", ")", ":", "sumP", "=", "(", "sumP", "*", "p", ")", "+", "cc", "[", "k", "]", "Fp", "[", "m", "]", "=", "sumP", "# preparation of the new coefficients", "for", "k", "in", "range", "(", "0", ",", "2", "*", "J", "-", "m", "-", "1", ")", ":", "cc", "[", "k", "]", "=", "(", "k", "+", "1", ")", "*", "cc", "[", "k", "+", "1", "]", "# COMPUTING THE NUMBERS d[n,k]", "# See II Section 3.17", "# First we compute the working precisions wpd[k]", "# Se II equation (92)", "wpd", "=", "{", "}", "d1", "=", "max", "(", "6", ",", "ctx", ".", "mag", "(", "40", "*", "L", "*", "L", ")", ")", "d2", "=", "13", "+", "ctx", ".", "mag", "(", "(", "1", "+", "abs", "(", "sigma", ")", ")", "*", "A", ")", "-", "ctx", ".", "mag", "(", "eps4", ")", "-", "1", "const", "=", "ctx", ".", "ln", "(", "8", "/", "(", "ctx", ".", "pi", "*", "ctx", ".", "pi", "*", "a", "*", "a", "*", "B1", "*", "B1", ")", ")", "/", "2", "for", "n", "in", "range", "(", "0", ",", "L", ")", ":", "d3", "=", "ctx", ".", "mag", "(", "ctx", ".", "sqrt", "(", "ctx", ".", "gamma", "(", "n", "-", "0.5", ")", ")", ")", "-", "ctx", ".", "floor", "(", "n", "*", "const", ")", "+", "d2", "wpd", "[", "n", "]", "=", "max", "(", "d3", ",", "d1", ")", "# procedure of II Section 3.17", "ctx", ".", "prec", "=", "wpd", "[", "1", "]", "+", "10", "psigma", "=", "1", "-", "(", "2", "*", "sigma", ")", "d", "=", "{", "}", "d", "[", "0", ",", "0", ",", "-", "2", "]", "=", "0", "d", "[", "0", ",", "0", ",", "-", "1", "]", "=", "0", "d", "[", "0", ",", "0", ",", "0", "]", "=", "1", "d", "[", "0", ",", "0", ",", "1", "]", "=", "0", "d", "[", "0", ",", "-", "1", ",", "-", "2", "]", "=", "0", "d", "[", "0", ",", "-", "1", ",", "-", "1", "]", "=", "0", "d", "[", "0", ",", "-", "1", ",", "0", "]", "=", "1", "d", "[", "0", ",", "-", "1", ",", "1", "]", "=", "0", "for", "n", "in", "range", "(", "1", ",", "L", ")", ":", "ctx", ".", "prec", "=", "wpd", "[", "n", "]", "+", "10", "for", "k", "in", "range", "(", "0", ",", "3", "*", "n", "//", "2", "+", "1", ")", ":", "m", "=", "3", "*", "n", "-", "2", "*", "k", "if", "(", "m", "!=", "0", ")", ":", "m1", "=", "ctx", ".", "one", "/", "m", "c1", "=", "m1", "/", "4", "c2", "=", "(", "psigma", "*", "m1", ")", "/", "2", "c3", "=", "-", "(", "m", "+", "1", ")", "d", "[", "0", ",", "n", ",", "k", "]", "=", "c3", "*", "d", "[", "0", ",", "n", "-", "1", ",", "k", "-", "2", "]", "+", "c1", "*", "d", "[", "0", ",", "n", "-", "1", ",", "k", "]", "+", "c2", "*", "d", "[", "0", ",", "n", "-", "1", ",", "k", "-", "1", "]", "else", ":", "d", "[", "0", ",", "n", ",", "k", "]", "=", "0", "for", "r", "in", "range", "(", "0", ",", "k", ")", ":", "add", "=", "d", "[", "0", ",", "n", ",", "r", "]", "*", "(", "ctx", ".", "one", "*", "ctx", ".", "fac", "(", "2", "*", "k", "-", "2", "*", "r", ")", "/", "ctx", ".", "fac", "(", "k", "-", "r", ")", ")", "d", "[", "0", ",", "n", ",", "k", "]", "-=", "(", "(", "-", "1", ")", "**", "(", "k", "-", "r", ")", ")", "*", "add", "d", "[", "0", ",", "n", ",", "-", "2", "]", "=", "0", "d", "[", "0", ",", "n", ",", "-", "1", "]", "=", "0", "d", "[", "0", ",", "n", ",", "3", "*", "n", "//", "2", "+", "1", "]", "=", "0", "for", "mu", "in", "range", "(", "-", "2", ",", "der", "+", "1", ")", ":", "for", "n", "in", "range", "(", "-", "2", ",", "L", ")", ":", "for", "k", "in", "range", "(", "-", "3", ",", "max", "(", "1", ",", "3", "*", "n", "//", "2", "+", "2", ")", ")", ":", "if", "(", "(", "mu", "<", "0", ")", "or", "(", "n", "<", "0", ")", "or", "(", "k", "<", "0", ")", "or", "(", "k", ">", "3", "*", "n", "//", "2", ")", ")", ":", "d", "[", "mu", ",", "n", ",", "k", "]", "=", "0", "for", "mu", "in", "range", "(", "1", ",", "der", "+", "1", ")", ":", "for", "n", "in", "range", "(", "0", ",", "L", ")", ":", "ctx", ".", "prec", "=", "wpd", "[", "n", "]", "+", "10", "for", "k", "in", "range", "(", "0", ",", "3", "*", "n", "//", "2", "+", "1", ")", ":", "aux", "=", "(", "2", "*", "mu", "-", "2", ")", "*", "d", "[", "mu", "-", "2", ",", "n", "-", "2", ",", "k", "-", "3", "]", "+", "2", "*", "(", "sigma", "+", "n", "-", "2", ")", "*", "d", "[", "mu", "-", "1", ",", "n", "-", "2", ",", "k", "-", "3", "]", "d", "[", "mu", ",", "n", ",", "k", "]", "=", "aux", "-", "d", "[", "mu", "-", "1", ",", "n", "-", "1", ",", "k", "-", "1", "]", "# COMPUTING THE COEFFICIENTS t[k,l]", "# See II Section 3.9", "#", "# computing the needed wp", "wptcoef", "=", "{", "}", "wpterm", "=", "{", "}", "ctx", ".", "prec", "=", "15", "c1", "=", "ctx", ".", "mag", "(", "40", "*", "(", "L", "+", "2", ")", ")", "c2", "=", "ctx", ".", "mag", "(", "68", "*", "(", "L", "+", "2", ")", "*", "A", ")", "c4", "=", "ctx", ".", "mag", "(", "B1", "*", "a", "*", "math", ".", "sqrt", "(", "ctx", ".", "pi", ")", ")", "-", "1", "for", "k", "in", "range", "(", "0", ",", "L", ")", ":", "c3", "=", "c2", "-", "k", "*", "c4", "+", "ctx", ".", "mag", "(", "ctx", ".", "fac", "(", "k", "+", "0.5", ")", ")", "/", "2.", "wptcoef", "[", "k", "]", "=", "max", "(", "c1", ",", "c3", "-", "ctx", ".", "mag", "(", "eps4", ")", "+", "1", ")", "+", "1", "+", "10", "wpterm", "[", "k", "]", "=", "max", "(", "c1", ",", "ctx", ".", "mag", "(", "L", "+", "2", ")", "+", "c3", "-", "ctx", ".", "mag", "(", "eps3", ")", "+", "1", ")", "+", "1", "+", "10", "# check of power of pi", "# computing the fortcoef[mu,k,ell]", "fortcoef", "=", "{", "}", "for", "mu", "in", "derivatives", ":", "for", "k", "in", "range", "(", "0", ",", "L", ")", ":", "for", "ell", "in", "range", "(", "-", "2", ",", "3", "*", "k", "//", "2", "+", "1", ")", ":", "fortcoef", "[", "mu", ",", "k", ",", "ell", "]", "=", "0", "for", "mu", "in", "derivatives", ":", "for", "k", "in", "range", "(", "0", ",", "L", ")", ":", "ctx", ".", "prec", "=", "wptcoef", "[", "k", "]", "for", "ell", "in", "range", "(", "0", ",", "3", "*", "k", "//", "2", "+", "1", ")", ":", "fortcoef", "[", "mu", ",", "k", ",", "ell", "]", "=", "d", "[", "mu", ",", "k", ",", "ell", "]", "*", "Fp", "[", "3", "*", "k", "-", "2", "*", "ell", "]", "/", "pipowers", "[", "2", "*", "k", "-", "ell", "]", "fortcoef", "[", "mu", ",", "k", ",", "ell", "]", "=", "fortcoef", "[", "mu", ",", "k", ",", "ell", "]", "/", "(", "(", "2", "*", "ctx", ".", "j", ")", "**", "ell", ")", "def", "trunc_a", "(", "t", ")", ":", "wp", "=", "ctx", ".", "prec", "ctx", ".", "prec", "=", "wp", "+", "2", "aa", "=", "ctx", ".", "sqrt", "(", "t", "/", "(", "2", "*", "ctx", ".", "pi", ")", ")", "ctx", ".", "prec", "=", "wp", "return", "aa", "# computing the tcoef[chi,k,ell]", "tcoef", "=", "{", "}", "for", "chi", "in", "derivatives", ":", "for", "k", "in", "range", "(", "0", ",", "L", ")", ":", "for", "ell", "in", "range", "(", "-", "2", ",", "3", "*", "k", "//", "2", "+", "1", ")", ":", "tcoef", "[", "chi", ",", "k", ",", "ell", "]", "=", "0", "ctx", ".", "prec", "=", "wptcoef", "[", "0", "]", "+", "3", "aa", "=", "trunc_a", "(", "t", ")", "la", "=", "-", "ctx", ".", "ln", "(", "aa", ")", "for", "chi", "in", "derivatives", ":", "for", "k", "in", "range", "(", "0", ",", "L", ")", ":", "ctx", ".", "prec", "=", "wptcoef", "[", "k", "]", "for", "ell", "in", "range", "(", "0", ",", "3", "*", "k", "//", "2", "+", "1", ")", ":", "tcoef", "[", "chi", ",", "k", ",", "ell", "]", "=", "0", "for", "mu", "in", "range", "(", "0", ",", "chi", "+", "1", ")", ":", "tcoefter", "=", "ctx", ".", "binomial", "(", "chi", ",", "mu", ")", "*", "la", "**", "mu", "*", "fortcoef", "[", "chi", "-", "mu", ",", "k", ",", "ell", "]", "tcoef", "[", "chi", ",", "k", ",", "ell", "]", "+=", "tcoefter", "# COMPUTING tv[k,ell]", "# See II Section 3.8", "# Computing the powers av[k] = a**(-k)", "ctx", ".", "prec", "=", "wptcoef", "[", "0", "]", "+", "2", "# a has a good value of a.", "# See II Section 3.6", "av", "=", "{", "}", "av", "[", "0", "]", "=", "1", "av", "[", "1", "]", "=", "av", "[", "0", "]", "/", "a", "ctx", ".", "prec", "=", "wptcoef", "[", "0", "]", "for", "k", "in", "range", "(", "2", ",", "L", ")", ":", "av", "[", "k", "]", "=", "av", "[", "k", "-", "1", "]", "*", "av", "[", "1", "]", "# Computing the quotients", "tv", "=", "{", "}", "for", "chi", "in", "derivatives", ":", "for", "k", "in", "range", "(", "0", ",", "L", ")", ":", "ctx", ".", "prec", "=", "wptcoef", "[", "k", "]", "for", "ell", "in", "range", "(", "0", ",", "3", "*", "k", "//", "2", "+", "1", ")", ":", "tv", "[", "chi", ",", "k", ",", "ell", "]", "=", "tcoef", "[", "chi", ",", "k", ",", "ell", "]", "*", "av", "[", "k", "]", "# COMPUTING THE TERMS term[k]", "# See II Section 3.6", "term", "=", "{", "}", "for", "chi", "in", "derivatives", ":", "for", "n", "in", "range", "(", "0", ",", "L", ")", ":", "ctx", ".", "prec", "=", "wpterm", "[", "n", "]", "te", "=", "0", "for", "k", "in", "range", "(", "0", ",", "3", "*", "n", "//", "2", "+", "1", ")", ":", "te", "+=", "tv", "[", "chi", ",", "n", ",", "k", "]", "term", "[", "chi", ",", "n", "]", "=", "te", "# COMPUTING rssum", "# See II Section 3.5", "rssum", "=", "{", "}", "ctx", ".", "prec", "=", "15", "rsbound", "=", "math", ".", "sqrt", "(", "ctx", ".", "pi", ")", "*", "c", "/", "(", "b", "*", "a", ")", "ctx", ".", "prec", "=", "15", "wprssum", "=", "ctx", ".", "mag", "(", "4.4", "*", "(", "(", "L", "+", "3", ")", "**", "2", ")", "*", "rsbound", "/", "eps2", ")", "wprssum", "=", "max", "(", "wprssum", ",", "ctx", ".", "mag", "(", "10", "*", "(", "L", "+", "1", ")", ")", ")", "ctx", ".", "prec", "=", "wprssum", "for", "chi", "in", "derivatives", ":", "rssum", "[", "chi", "]", "=", "0", "for", "k", "in", "range", "(", "1", ",", "L", "+", "1", ")", ":", "rssum", "[", "chi", "]", "+=", "term", "[", "chi", ",", "L", "-", "k", "]", "# COMPUTING S3", "# See II Section 3.19", "ctx", ".", "prec", "=", "15", "A2", "=", "2", "**", "(", "ctx", ".", "mag", "(", "rssum", "[", "0", "]", ")", ")", "eps8", "=", "eps", "/", "(", "3", "*", "A2", ")", "T", "=", "t", "*", "ctx", ".", "ln", "(", "t", "/", "(", "2", "*", "ctx", ".", "pi", ")", ")", "wps3", "=", "5", "+", "ctx", ".", "mag", "(", "(", "1", "+", "(", "2", "/", "eps8", ")", "*", "ctx", ".", "power", "(", "a", ",", "-", "sigma", ")", ")", "*", "T", ")", "ctx", ".", "prec", "=", "wps3", "tpi", "=", "t", "/", "(", "2", "*", "ctx", ".", "pi", ")", "arg", "=", "(", "t", "/", "2", ")", "*", "ctx", ".", "ln", "(", "tpi", ")", "-", "(", "t", "/", "2", ")", "-", "ctx", ".", "pi", "/", "8", "U", "=", "ctx", ".", "expj", "(", "-", "arg", ")", "a", "=", "trunc_a", "(", "t", ")", "asigma", "=", "ctx", ".", "power", "(", "a", ",", "-", "sigma", ")", "S3", "=", "(", "(", "-", "1", ")", "**", "(", "N", "-", "1", ")", ")", "*", "asigma", "*", "U", "# COMPUTING S1 the zetasum", "# See II Section 3.18", "ctx", ".", "prec", "=", "15", "wpsum", "=", "4", "+", "ctx", ".", "mag", "(", "(", "N", "+", "ctx", ".", "power", "(", "N", ",", "1", "-", "sigma", ")", ")", "*", "ctx", ".", "ln", "(", "N", ")", "/", "eps1", ")", "ctx", ".", "prec", "=", "wpsum", "+", "10", "'''\n # This can be improved\n S1 = {}\n for chi in derivatives:\n S1[chi] = 0\n for n in range(1,int(N)+1):\n ln = ctx.ln(n)\n expn = ctx.exp(-ln*(sigma+ctx.j*t))\n for chi in derivatives:\n term = ctx.power(-ln, chi)*expn\n S1[chi] += term\n '''", "S1", "=", "ctx", ".", "_zetasum", "(", "s", ",", "1", ",", "int", "(", "N", ")", "-", "1", ",", "derivatives", ")", "[", "0", "]", "# END OF COMPUTATION", "# See II Section 3.1", "ctx", ".", "prec", "=", "15", "absS1", "=", "abs", "(", "S1", "[", "der", "]", ")", "absS2", "=", "abs", "(", "rssum", "[", "der", "]", "*", "S3", ")", "wpend", "=", "max", "(", "6", ",", "wpinitial", "+", "ctx", ".", "mag", "(", "6", "*", "(", "3", "*", "absS1", "+", "7", "*", "absS2", ")", ")", ")", "ctx", ".", "prec", "=", "wpend", "rz", "=", "{", "}", "for", "chi", "in", "derivatives", ":", "rz", "[", "chi", "]", "=", "S1", "[", "chi", "]", "+", "rssum", "[", "chi", "]", "*", "S3", "ctx", ".", "prec", "=", "wpinitial", "return", "rz" ]

[]

[ "def", "__init__", "(", "self", ",", "quat", ",", "cumulative", "=", "False", ")", ":", "self", ".", "_quat", "=", "quat", "self", ".", "_cumulative", "=", "cumulative" ]

[ "Turn", "a", "netmask", "/", "hostmask", "string", "into", "a", "prefix", "length", "." ]

[ "def", "_prefix_from_ip_string", "(", "self", ",", "ip_str", ")", ":", "# Parse the netmask/hostmask like an IP address.", "try", ":", "ip_int", "=", "self", ".", "_ip_int_from_string", "(", "ip_str", ")", "except", "AddressValueError", ":", "raise", "NetmaskValueError", "(", "'%s is not a valid netmask'", "%", "ip_str", ")", "# Try matching a netmask (this would be /1*0*/ as a bitwise regexp).", "# Note that the two ambiguous cases (all-ones and all-zeroes) are", "# treated as netmasks.", "try", ":", "return", "self", ".", "_prefix_from_ip_int", "(", "ip_int", ")", "except", "NetmaskValueError", ":", "pass", "# Invert the bits, and try matching a /0+1+/ hostmask instead.", "ip_int", "^=", "self", ".", "_ALL_ONES", "try", ":", "return", "self", ".", "_prefix_from_ip_int", "(", "ip_int", ")", "except", "NetmaskValueError", ":", "raise", "NetmaskValueError", "(", "'%s is not a valid netmask'", "%", "ip_str", ")" ]

[ "Writes", "datachars", "to", "writer", "." ]

[ "def", "_write_data", "(", "writer", ",", "data", ")", ":", "data", "=", "data", ".", "replace", "(", "\"&\"", ",", "\"&amp;\"", ")", ".", "replace", "(", "\"<\"", ",", "\"&lt;\"", ")", "data", "=", "data", ".", "replace", "(", "\"\\\"\"", ",", "\"&quot;\"", ")", ".", "replace", "(", "\">\"", ",", "\"&gt;\"", ")", "writer", ".", "write", "(", "data", ")" ]

[ "filter", "survey", "field" ]

[ "def", "get_fields", "(", "self", ",", "*", "args", ",", "*", "*", "kwargs", ")", ":", "fields", "=", "super", "(", "DNCContactSerializer", ",", "self", ")", ".", "get_fields", "(", "*", "args", ",", "*", "*", "kwargs", ")", "request", "=", "self", ".", "context", "[", "'request'", "]", "if", "request", ".", "method", "!=", "'GET'", "and", "self", ".", "init_data", "is", "not", "None", ":", "dnc", "=", "self", ".", "init_data", ".", "get", "(", "'dnc'", ")", "if", "dnc", "and", "dnc", ".", "find", "(", "'http://'", ")", "==", "-", "1", ":", "try", ":", "DNC", ".", "objects", ".", "get", "(", "pk", "=", "int", "(", "dnc", ")", ")", "self", ".", "init_data", "[", "'dnc'", "]", "=", "'/rest-api/dnc-list/%s/'", "%", "dnc", "except", ":", "self", ".", "init_data", "[", "'dnc'", "]", "=", "''", "pass", "if", "request", ".", "method", "!=", "'GET'", ":", "fields", "[", "'dnc'", "]", ".", "queryset", "=", "DNC", ".", "objects", ".", "filter", "(", "user", "=", "request", ".", "user", ")", "return", "fields" ]

[ "Set", "the", "Format", "bg_color", "property", "." ]

[ "def", "set_bg_color", "(", "self", ",", "bg_color", ")", ":", "self", ".", "bg_color", "=", "self", ".", "_get_color", "(", "bg_color", ")" ]

[ "Convert", "keyserver", "to", "format", ":", "protocol", ":", "//", "domain", ":", "port" ]

[ "def", "clean_keyserver", "(", "self", ",", "keyserver", ")", ":", "o", "=", "urlparse", "(", "keyserver", ")", "# Scheme and port", "scheme", "=", "o", ".", "scheme", "if", "scheme", "==", "b'hkp'", ":", "port", "=", "80", "elif", "scheme", "==", "b'hkps'", ":", "port", "=", "443", "else", ":", "scheme", "=", "b'hkp'", "port", "=", "80", "# Domain", "domain", "=", "o", ".", "netloc", "if", "domain", "==", "b''", ":", "domain", "=", "o", ".", "path", ".", "strip", "(", "b'/'", ")", "# Does the domain include a port?", "if", "b':'", "in", "domain", ":", "parts", "=", "domain", ".", "split", "(", "b':'", ")", "domain", "=", "parts", "[", "0", "]", "port", "=", "int", "(", "parts", "[", "1", "]", ")", "return", "scheme", "+", "b'://'", "+", "domain", "+", "b':'", "+", "str", "(", "port", ")", ".", "encode", "(", ")" ]

[ "Resume", "the", "optimizers", "and", "schedulers", "for", "training" ]

[ "def", "resume_training", "(", "self", ",", "resume_state", ")", ":", "resume_optimizers", "=", "resume_state", "[", "'optimizers'", "]", "resume_schedulers", "=", "resume_state", "[", "'schedulers'", "]", "assert", "len", "(", "resume_optimizers", ")", "==", "len", "(", "self", ".", "optimizers", ")", ",", "'Wrong lengths of optimizers'", "assert", "len", "(", "resume_schedulers", ")", "==", "len", "(", "self", ".", "schedulers", ")", ",", "'Wrong lengths of schedulers'", "for", "i", ",", "o", "in", "enumerate", "(", "resume_optimizers", ")", ":", "self", ".", "optimizers", "[", "i", "]", ".", "load_state_dict", "(", "o", ")", "for", "i", ",", "s", "in", "enumerate", "(", "resume_schedulers", ")", ":", "self", ".", "schedulers", "[", "i", "]", ".", "load_state_dict", "(", "s", ")" ]

[ "Sort", "generators", "in", "a", "reasonably", "intelligent", "way", "." ]

[ "def", "_sort_gens", "(", "gens", ",", "*", "*", "args", ")", ":", "opt", "=", "build_options", "(", "args", ")", "gens_order", ",", "wrt", "=", "{", "}", ",", "None", "if", "opt", "is", "not", "None", ":", "gens_order", ",", "wrt", "=", "{", "}", ",", "opt", ".", "wrt", "for", "i", ",", "gen", "in", "enumerate", "(", "opt", ".", "sort", ")", ":", "gens_order", "[", "gen", "]", "=", "i", "+", "1", "def", "order_key", "(", "gen", ")", ":", "gen", "=", "str", "(", "gen", ")", "if", "wrt", "is", "not", "None", ":", "try", ":", "return", "(", "-", "len", "(", "wrt", ")", "+", "wrt", ".", "index", "(", "gen", ")", ",", "gen", ",", "0", ")", "except", "ValueError", ":", "pass", "name", ",", "index", "=", "_re_gen", ".", "match", "(", "gen", ")", ".", "groups", "(", ")", "if", "index", ":", "index", "=", "int", "(", "index", ")", "else", ":", "index", "=", "0", "try", ":", "return", "(", "gens_order", "[", "name", "]", ",", "name", ",", "index", ")", "except", "KeyError", ":", "pass", "try", ":", "return", "(", "_gens_order", "[", "name", "]", ",", "name", ",", "index", ")", "except", "KeyError", ":", "pass", "return", "(", "_max_order", ",", "name", ",", "index", ")", "try", ":", "gens", "=", "sorted", "(", "gens", ",", "key", "=", "order_key", ")", "except", "TypeError", ":", "# pragma: no cover", "pass", "return", "tuple", "(", "gens", ")" ]

[ "Initializes", "the", "project", "." ]

[ "def", "__init__", "(", "self", ",", "project_path", ",", "version", ",", "name", ",", "guid", "=", "None", ",", "platforms", "=", "None", ")", ":", "self", ".", "project_path", "=", "project_path", "self", ".", "version", "=", "version", "self", ".", "name", "=", "name", "self", ".", "guid", "=", "guid", "# Default to Win32 for platforms.", "if", "not", "platforms", ":", "platforms", "=", "[", "'Win32'", "]", "# Initialize the specifications of the various sections.", "self", ".", "platform_section", "=", "[", "'Platforms'", "]", "for", "platform", "in", "platforms", ":", "self", ".", "platform_section", ".", "append", "(", "[", "'Platform'", ",", "{", "'Name'", ":", "platform", "}", "]", ")", "self", ".", "tool_files_section", "=", "[", "'ToolFiles'", "]", "self", ".", "configurations_section", "=", "[", "'Configurations'", "]", "self", ".", "files_section", "=", "[", "'Files'", "]", "# Keep a dict keyed on filename to speed up access.", "self", ".", "files_dict", "=", "dict", "(", ")" ]

[ "Whether", "BLAS", "routines", "can", "be", "applied", "or", "not", "." ]

[ "def", "_blas_is_applicable", "(", "*", "args", ")", ":", "if", "any", "(", "x", ".", "dtype", "!=", "args", "[", "0", "]", ".", "dtype", "for", "x", "in", "args", "[", "1", ":", "]", ")", ":", "return", "False", "elif", "any", "(", "x", ".", "dtype", "not", "in", "_BLAS_DTYPES", "for", "x", "in", "args", ")", ":", "return", "False", "elif", "not", "(", "all", "(", "x", ".", "flags", ".", "f_contiguous", "for", "x", "in", "args", ")", "or", "all", "(", "x", ".", "flags", ".", "c_contiguous", "for", "x", "in", "args", ")", ")", ":", "return", "False", "elif", "any", "(", "x", ".", "size", ">", "np", ".", "iinfo", "(", "'int32'", ")", ".", "max", "for", "x", "in", "args", ")", ":", "# Temporary fix for 32 bit int overflow in BLAS", "# TODO: use chunking instead", "return", "False", "else", ":", "return", "True" ]

[]

[ "def", "info", "(", "self", ")", ":", "return", "_api_scrape", "(", "self", ".", "json", ",", "0", ")" ]

[ "Updates", "the", "SDK", "with", "the", "given", "identifier", "." ]

[ "def", "update_sdk", "(", "self", ",", "sdk_id", ",", "update_sdk_details", ",", "*", "*", "kwargs", ")", ":", "resource_path", "=", "\"/sdks/{sdkId}\"", "method", "=", "\"PUT\"", "# Don't accept unknown kwargs", "expected_kwargs", "=", "[", "\"retry_strategy\"", ",", "\"if_match\"", ",", "\"opc_request_id\"", "]", "extra_kwargs", "=", "[", "_key", "for", "_key", "in", "six", ".", "iterkeys", "(", "kwargs", ")", "if", "_key", "not", "in", "expected_kwargs", "]", "if", "extra_kwargs", ":", "raise", "ValueError", "(", "\"update_sdk got unknown kwargs: {!r}\"", ".", "format", "(", "extra_kwargs", ")", ")", "path_params", "=", "{", "\"sdkId\"", ":", "sdk_id", "}", "path_params", "=", "{", "k", ":", "v", "for", "(", "k", ",", "v", ")", "in", "six", ".", "iteritems", "(", "path_params", ")", "if", "v", "is", "not", "missing", "}", "for", "(", "k", ",", "v", ")", "in", "six", ".", "iteritems", "(", "path_params", ")", ":", "if", "v", "is", "None", "or", "(", "isinstance", "(", "v", ",", "six", ".", "string_types", ")", "and", "len", "(", "v", ".", "strip", "(", ")", ")", "==", "0", ")", ":", "raise", "ValueError", "(", "'Parameter {} cannot be None, whitespace or empty string'", ".", "format", "(", "k", ")", ")", "header_params", "=", "{", "\"accept\"", ":", "\"application/json\"", ",", "\"content-type\"", ":", "\"application/json\"", ",", "\"if-match\"", ":", "kwargs", ".", "get", "(", "\"if_match\"", ",", "missing", ")", ",", "\"opc-request-id\"", ":", "kwargs", ".", "get", "(", "\"opc_request_id\"", ",", "missing", ")", "}", "header_params", "=", "{", "k", ":", "v", "for", "(", "k", ",", "v", ")", "in", "six", ".", "iteritems", "(", "header_params", ")", "if", "v", "is", "not", "missing", "and", "v", "is", "not", "None", "}", "retry_strategy", "=", "self", ".", "base_client", ".", "get_preferred_retry_strategy", "(", "operation_retry_strategy", "=", "kwargs", ".", "get", "(", "'retry_strategy'", ")", ",", "client_retry_strategy", "=", "self", ".", "retry_strategy", ")", "if", "retry_strategy", ":", "if", "not", "isinstance", "(", "retry_strategy", ",", "retry", ".", "NoneRetryStrategy", ")", ":", "self", ".", "base_client", ".", "add_opc_client_retries_header", "(", "header_params", ")", "retry_strategy", ".", "add_circuit_breaker_callback", "(", "self", ".", "circuit_breaker_callback", ")", "return", "retry_strategy", ".", "make_retrying_call", "(", "self", ".", "base_client", ".", "call_api", ",", "resource_path", "=", "resource_path", ",", "method", "=", "method", ",", "path_params", "=", "path_params", ",", "header_params", "=", "header_params", ",", "body", "=", "update_sdk_details", ")", "else", ":", "return", "self", ".", "base_client", ".", "call_api", "(", "resource_path", "=", "resource_path", ",", "method", "=", "method", ",", "path_params", "=", "path_params", ",", "header_params", "=", "header_params", ",", "body", "=", "update_sdk_details", ")" ]

[ "Write", "the", "frame", "into", "an", "existing", "buffer", "." ]

[ "def", "write_frame", "(", "self", ",", "buf", ")", ":", "writer", "=", "Writer", "(", "buf", ")", "writer", ".", "write_octet", "(", "self", ".", "type", "(", ")", ")", ".", "write_short", "(", "self", ".", "channel_id", ")", ".", "write_long", "(", "len", "(", "self", ".", "_payload", ")", ")", ".", "write", "(", "self", ".", "_payload", ")", ".", "write_octet", "(", "0xce", ")" ]

[ "Returns", "True", "if", "the", "package", "is", "in", "the", "local", "package", "repository" ]

[ "def", "is_local", "(", "self", ")", ":", "local_repo", "=", "package_repository_manager", ".", "get_repository", "(", "self", ".", "config", ".", "local_packages_path", ")", "return", "(", "self", ".", "resource", ".", "_repository", ".", "uid", "==", "local_repo", ".", "uid", ")" ]

[ "Sets", "trim_user", "parameter", ".", "When", "set", "to", "True", "\\", "each", "tweet", "returned", "in", "a", "timeline", "will", "include", "a", "\\", "user", "object", "including", "only", "the", "status", "authors", "numerical", "ID" ]

[ "def", "set_trim_user", "(", "self", ",", "trim", ")", ":", "if", "not", "isinstance", "(", "trim", ",", "bool", ")", ":", "raise", "TwitterSearchException", "(", "1008", ")", "self", ".", "arguments", ".", "update", "(", "{", "'trim_user'", ":", "'true'", "if", "trim", "else", "'false'", "}", ")" ]

[]

[ "def", "__init__", "(", "self", ",", "func", ",", "graph", "=", "None", ")", ":", "super", "(", "FunctionGraphVisitor", ",", "self", ")", ".", "__init__", "(", ")", "self", ".", "function", "=", "func", "if", "graph", "is", "None", ":", "self", ".", "graph", "=", "self", ".", "function", ".", "graph", "else", ":", "self", ".", "graph", "=", "graph", "self", ".", "reset", "(", ")" ]

[ "This", "method", "of", "XMLParser", "is", "deprecated", "." ]

[ "def", "doctype", "(", "self", ",", "name", ",", "pubid", ",", "system", ")", ":", "warnings", ".", "warn", "(", "\"This method of XMLParser is deprecated. Define doctype() \"", "\"method on the TreeBuilder target.\"", ",", "DeprecationWarning", ",", ")" ]

[ "Logs", "an", "exception", ".", "This", "is", "called", "by", ":", "meth", ":", "handle_exception", "if", "debugging", "is", "disabled", "and", "right", "before", "the", "handler", "is", "called", ".", "The", "default", "implementation", "logs", "the", "exception", "as", "error", "on", "the", ":", "attr", ":", "logger", "." ]

[ "def", "log_exception", "(", "self", ",", "exc_info", ")", ":", "self", ".", "logger", ".", "error", "(", "'Exception on %s [%s]'", "%", "(", "request", ".", "path", ",", "request", ".", "method", ")", ",", "exc_info", "=", "exc_info", ")" ]

[ "This", "method", "returns", "the", "auth", "key", "generated", "by", "the", "constructor", "." ]

[ "def", "getAuthKey", "(", "self", ")", ":", "return", "self", ".", "auth_key" ]

[]

[ "def", "init_argparse", "(", "self", ")", ":", "self", ".", "arg_parser", "=", "PupyArgumentParser", "(", "prog", "=", "'get_info'", ",", "description", "=", "self", ".", "__doc__", ")" ]

[]

[ "def", "main", "(", ")", ":", "# Much much imports :)", "updateHandler", "=", "Updater", "eulaHandler", "=", "EULA", "(", ")", "bannerHandler", "=", "muchmuchstrings", ".", "banners", "(", ")", "db", "=", "db_handler", ".", "DBHandler", "(", ")", "terminalHandler", "=", "Controller", "(", ")", "def", "filter_array", "(", "array", ",", "colum", ",", "value", ")", ":", "ret_array", "=", "[", "row", "for", "row", "in", "array", "if", "value", "in", "row", "[", "colum", "]", "]", "return", "ret_array", "def", "getArgvs", "(", ")", ":", "parser", "=", "OptionParser", "(", ")", "parser", "=", "OptionParser", "(", ")", "parser", ".", "add_option", "(", "\"-f\"", ",", "\"--filter\"", ",", "dest", "=", "\"mal_filter\"", ",", "default", "=", "[", "]", ",", "help", "=", "\"Filter the malwares.\"", ",", "action", "=", "\"append\"", ")", "parser", ".", "add_option", "(", "\"-u\"", ",", "\"--update\"", ",", "dest", "=", "\"update_bol\"", ",", "default", "=", "0", ",", "help", "=", "\"Updates the DB of theZoo.\"", ",", "action", "=", "\"store_true\"", ")", "parser", ".", "add_option", "(", "\"-v\"", ",", "\"--version\"", ",", "dest", "=", "\"ver_bol\"", ",", "default", "=", "0", ",", "help", "=", "\"Shows version and licensing information.\"", ",", "action", "=", "\"store_true\"", ")", "parser", ".", "add_option", "(", "\"-w\"", ",", "\"--license\"", ",", "dest", "=", "\"license_bol\"", ",", "default", "=", "0", ",", "help", "=", "\"Prints the GPLv3 license information.\"", ",", "action", "=", "\"store_true\"", ")", "(", "options", ",", "args", ")", "=", "parser", ".", "parse_args", "(", ")", "return", "options", "# Here actually starts Main()", "arguments", "=", "getArgvs", "(", ")", "# Checking for EULA Agreement", "a", "=", "eulaHandler", ".", "check_eula_file", "(", ")", "if", "a", "==", "0", ":", "eulaHandler", ".", "prompt_eula", "(", ")", "# Get arguments", "# Check if update flag is on", "if", "arguments", ".", "update_bol", "==", "1", ":", "a", "=", "Updater", "(", ")", "with", "open", "(", "'conf/db.ver'", ",", "'r'", ")", "as", "f", ":", "a", ".", "update_db", "(", "f", ".", "readline", "(", ")", ")", "sys", ".", "exit", "(", "1", ")", "# Check if version flag is on", "if", "arguments", ".", "ver_bol", "==", "1", ":", "print", "(", "vars", ".", "maldb_banner", ")", "sys", ".", "exit", "(", "1", ")", "# Check if license flag is on", "if", "arguments", ".", "license_bol", "==", "1", ":", "bannerHandler", ".", "print_license", "(", ")", "sys", ".", "exit", "(", "1", ")", "if", "len", "(", "arguments", ".", "mal_filter", ")", ">", "0", ":", "manySearch", "=", "manysearches", ".", "MuchSearch", "(", ")", "print", "(", "vars", ".", "maldb_banner", ")", "manySearch", ".", "sort", "(", "arguments", ".", "mal_filter", ")", "sys", ".", "exit", "(", "1", ")", "# Initiate normal run. No arguments given.", "os", ".", "system", "(", "'cls'", "if", "os", ".", "name", "==", "'nt'", "else", "'clear'", ")", "print", "(", "vars", ".", "maldb_banner", ")", "while", "1", ":", "terminalHandler", ".", "MainMenu", "(", ")", "sys", ".", "exit", "(", "1", ")" ]

[ "from", "object", "to", "str" ]

[ "def", "pickle_dumps_to_str", "(", "cls", ",", "obj", ")", ":", "try", ":", "#return base64.encodebytes(pickle.dumps(obj)).decode()", "#return base64.b64encode(pickle.dumps(obj))", "return", "base64", ".", "b64encode", "(", "pickle", ".", "dumps", "(", "obj", ")", ")", ".", "decode", "(", ")", "except", "pickle", ".", "PicklingError", ":", "pass" ]

[ "Delete", "model", "hook" ]

[ "def", "delete_model_hook", "(", "self", ",", "model_name", ",", "hook_name", ")", ":", "hooks_dir", "=", "self", ".", "model_hooks_dir", "(", "model_name", ")", "hook_path", "=", "self", ".", "_hook_path", "(", "hooks_dir", ",", "hook_name", ")", "try", ":", "os", ".", "unlink", "(", "hook_path", ")", "except", "FileNotFoundError", ":", "raise", "errors", ".", "NotFound", "(", "\"hook not found\"", ")" ]

[ "Combined", "multi", "dict", "for", ":", "attr", ":", "args", "and", ":", "attr", ":", "form", "." ]

[ "def", "values", "(", "self", ")", ":", "args", "=", "[", "]", "for", "d", "in", "self", ".", "args", ",", "self", ".", "form", ":", "if", "not", "isinstance", "(", "d", ",", "MultiDict", ")", ":", "d", "=", "MultiDict", "(", "d", ")", "args", ".", "append", "(", "d", ")", "return", "CombinedMultiDict", "(", "args", ")" ]

[ "Build", "params", "from", "input", "and", "args", "/", "kwargs" ]

[ "def", "wsdl_call_get_params", "(", "self", ",", "method", ",", "input", ",", "args", ",", "kwargs", ")", ":", "params", "=", "inputname", "=", "inputargs", "=", "None", "all_args", "=", "{", "}", "if", "input", ":", "inputname", "=", "list", "(", "input", ".", "keys", "(", ")", ")", "[", "0", "]", "inputargs", "=", "input", "[", "inputname", "]", "if", "input", "and", "args", ":", "# convert positional parameters to named parameters:", "d", "=", "{", "}", "for", "idx", ",", "arg", "in", "enumerate", "(", "args", ")", ":", "key", "=", "list", "(", "inputargs", ".", "keys", "(", ")", ")", "[", "idx", "]", "if", "isinstance", "(", "arg", ",", "dict", ")", ":", "if", "key", "not", "in", "arg", ":", "raise", "KeyError", "(", "'Unhandled key %s. use client.help(method)'", "%", "key", ")", "d", "[", "key", "]", "=", "arg", "[", "key", "]", "else", ":", "d", "[", "key", "]", "=", "arg", "all_args", ".", "update", "(", "{", "inputname", ":", "d", "}", ")", "if", "input", "and", "(", "kwargs", "or", "all_args", ")", ":", "if", "kwargs", ":", "all_args", ".", "update", "(", "{", "inputname", ":", "kwargs", "}", ")", "valid", ",", "errors", ",", "warnings", "=", "self", ".", "wsdl_validate_params", "(", "input", ",", "all_args", ")", "if", "not", "valid", ":", "raise", "ValueError", "(", "'Invalid Args Structure. Errors: %s'", "%", "errors", ")", "# sort and filter parameters according to wsdl input structure", "tree", "=", "sort_dict", "(", "input", ",", "all_args", ")", "root", "=", "list", "(", "tree", ".", "values", "(", ")", ")", "[", "0", "]", "params", "=", "[", "]", "# make a params tuple list suitable for self.call(method, *params)", "for", "k", ",", "v", "in", "root", ".", "items", "(", ")", ":", "# fix referenced namespaces as info is lost when calling call", "root_ns", "=", "root", ".", "namespaces", "[", "k", "]", "if", "not", "root", ".", "references", "[", "k", "]", "and", "isinstance", "(", "v", ",", "Struct", ")", ":", "v", ".", "namespaces", "[", "None", "]", "=", "root_ns", "params", ".", "append", "(", "(", "k", ",", "v", ")", ")", "# TODO: check style and document attributes", "if", "self", ".", "__soap_server", "in", "(", "'axis'", ",", ")", ":", "# use the operation name", "method", "=", "method", "else", ":", "# use the message (element) name", "method", "=", "inputname", "#elif not input:", "#TODO: no message! (see wsmtxca.dummy)", "else", ":", "params", "=", "kwargs", "and", "kwargs", ".", "items", "(", ")", "return", "(", "method", ",", "params", ")" ]

[ "Process", "a", "set", "()", "statement", "updating", "the", "variable", "assignments", "accordingly" ]

[ "def", "process_set_statement", "(", "argtree", ",", "variables", ")", ":", "varname", "=", "replace_varrefs", "(", "argtree", ".", "varname", ".", "spelling", ",", "variables", ")", "if", "not", "argtree", ".", "value_group", ":", "variables", ".", "pop", "(", "varname", ",", "None", ")", "return", "setargs", "=", "argtree", ".", "value_group", ".", "get_tokens", "(", "kind", "=", "\"semantic\"", ")", "valuestr", "=", "\";\"", ".", "join", "(", "arg", ".", "spelling", ".", "strip", "(", "'\"'", ")", "for", "arg", "in", "setargs", ")", "variables", "[", "varname", "]", "=", "replace_varrefs", "(", "valuestr", ",", "variables", ")" ]

[ "Annotate", "a", "pointer", "to", "include", "the", "code", "type", "metadata", "." ]

[ "def", "annotatePtr", "(", "self", ",", "ea", ",", "code_type", ")", ":", "return", "ea", "+", "code_type" ]

[ "r", "Method", "to", "calculate", "low", "-", "pressure", "gas", "viscosity", "at", "tempearture", "T", "with", "a", "given", "method", "." ]

[ "def", "calculate", "(", "self", ",", "T", ",", "method", ")", ":", "if", "method", "==", "GHARAGHEIZI", ":", "mu", "=", "viscosity_gas_Gharagheizi", "(", "T", ",", "self", ".", "Tc", ",", "self", ".", "Pc", ",", "self", ".", "MW", ")", "elif", "method", "==", "COOLPROP", ":", "mu", "=", "CoolProp_T_dependent_property", "(", "T", ",", "self", ".", "CASRN", ",", "'V'", ",", "'g'", ")", "elif", "method", "==", "DIPPR_PERRY_8E", ":", "mu", "=", "EQ102", "(", "T", ",", "*", "self", ".", "Perrys2_312_coeffs", ")", "elif", "method", "==", "VDI_PPDS", ":", "mu", "=", "horner", "(", "self", ".", "VDI_PPDS_coeffs", ",", "T", ")", "elif", "method", "==", "YOON_THODOS", ":", "mu", "=", "Yoon_Thodos", "(", "T", ",", "self", ".", "Tc", ",", "self", ".", "Pc", ",", "self", ".", "MW", ")", "elif", "method", "==", "STIEL_THODOS", ":", "mu", "=", "Stiel_Thodos", "(", "T", ",", "self", ".", "Tc", ",", "self", ".", "Pc", ",", "self", ".", "MW", ")", "elif", "method", "==", "LUCAS_GAS", ":", "mu", "=", "Lucas_gas", "(", "T", ",", "self", ".", "Tc", ",", "self", ".", "Pc", ",", "self", ".", "Zc", ",", "self", ".", "MW", ",", "self", ".", "dipole", ",", "CASRN", "=", "self", ".", "CASRN", ")", "else", ":", "return", "self", ".", "_base_calculate", "(", "T", ",", "method", ")", "return", "mu" ]

[ "Validate", "the", "certificate", "chain", "." ]

[ "def", "_validate_cert_chain", "(", "self", ",", "cert_chain", ")", ":", "# type: (bytes) -> None", "try", ":", "end_cert", "=", "None", "intermediate_certs", "=", "[", "]", "for", "type_name", ",", "headers", ",", "der_bytes", "in", "pem", ".", "unarmor", "(", "cert_chain", ",", "multiple", "=", "True", ")", ":", "if", "end_cert", "is", "None", ":", "end_cert", "=", "der_bytes", "else", ":", "intermediate_certs", ".", "append", "(", "der_bytes", ")", "validator", "=", "CertificateValidator", "(", "end_cert", ",", "intermediate_certs", ")", "validator", ".", "validate_usage", "(", "key_usage", "=", "{", "'digital_signature'", "}", ")", "except", "(", "PathError", ",", "ValidationError", ")", "as", "e", ":", "raise", "VerificationException", "(", "\"Certificate chain is not valid\"", ",", "e", ")" ]

[ "Tries", "to", "parse", "a", "datetime", "string", "scraped", "from", "HTML", "(", "web", "or", "email", ")", "." ]

[ "def", "_scraped_datetime", "(", "tag", ")", ":", "if", "not", "tag", ":", "return", "None", "try", ":", "# sadly using parse(fuzzy=True) here makes too many mistakes on relative", "# time strings seen on mbasic, eg '22 hrs [ago]', 'Yesterday at 12:34 PM'", "parsed", "=", "dateutil", ".", "parser", ".", "parse", "(", "tag", ".", "get_text", "(", "strip", "=", "True", ")", ",", "default", "=", "now_fn", "(", ")", ")", "return", "parsed", ".", "isoformat", "(", "'T'", ")", "except", "(", "ValueError", ",", "OverflowError", ")", ":", "logging", ".", "debug", "(", "f\"Couldn't parse datetime string {tag!r}\"", ")" ]

[ "Return", "the", "gender", "of", "the", "Person", "." ]

[ "def", "get_gender", "(", "self", ")", ":", "return", "self", ".", "__gender" ]

[ "Changes", "a", "MS", "smart", "quote", "character", "to", "an", "XML", "or", "HTML", "entity", "or", "an", "ASCII", "character", "." ]

[ "def", "_sub_ms_char", "(", "self", ",", "match", ")", ":", "orig", "=", "match", ".", "group", "(", "1", ")", "if", "self", ".", "smart_quotes_to", "==", "'ascii'", ":", "sub", "=", "self", ".", "MS_CHARS_TO_ASCII", ".", "get", "(", "orig", ")", ".", "encode", "(", ")", "else", ":", "sub", "=", "self", ".", "MS_CHARS", ".", "get", "(", "orig", ")", "if", "type", "(", "sub", ")", "==", "tuple", ":", "if", "self", ".", "smart_quotes_to", "==", "'xml'", ":", "sub", "=", "'&#x'", ".", "encode", "(", ")", "+", "sub", "[", "1", "]", ".", "encode", "(", ")", "+", "';'", ".", "encode", "(", ")", "else", ":", "sub", "=", "'&'", ".", "encode", "(", ")", "+", "sub", "[", "0", "]", ".", "encode", "(", ")", "+", "';'", ".", "encode", "(", ")", "else", ":", "sub", "=", "sub", ".", "encode", "(", ")", "return", "sub" ]

[ "Collect", "all", "input", "values", "attempt", "to", "process", "new", "output", "values", "and", "propagate", "downstream", ".", "Subclasses", "should", "call", "update", "()", "whenever", "thir", "internal", "state", "has", "changed", "(", "such", "as", "when", "the", "user", "interacts", "with", "the", "Node", "s", "control", "widget", ")", ".", "Update", "is", "automatically", "called", "when", "the", "inputs", "to", "the", "node", "are", "changed", "." ]

[ "def", "update", "(", "self", ",", "signal", "=", "True", ")", ":", "vals", "=", "self", ".", "inputValues", "(", ")", "#print \" inputs:\", vals", "try", ":", "if", "self", ".", "isBypassed", "(", ")", ":", "out", "=", "self", ".", "processBypassed", "(", "vals", ")", "else", ":", "out", "=", "self", ".", "process", "(", "*", "*", "strDict", "(", "vals", ")", ")", "#print \" output:\", out", "if", "out", "is", "not", "None", ":", "if", "signal", ":", "self", ".", "setOutput", "(", "*", "*", "out", ")", "else", ":", "self", ".", "setOutputNoSignal", "(", "*", "*", "out", ")", "for", "n", ",", "t", "in", "self", ".", "inputs", "(", ")", ".", "items", "(", ")", ":", "t", ".", "setValueAcceptable", "(", "True", ")", "self", ".", "clearException", "(", ")", "except", ":", "#printExc( \"Exception while processing %s:\" % self.name())", "for", "n", ",", "t", "in", "self", ".", "outputs", "(", ")", ".", "items", "(", ")", ":", "t", ".", "setValue", "(", "None", ")", "self", ".", "setException", "(", "sys", ".", "exc_info", "(", ")", ")", "if", "signal", ":", "#self.emit(QtCore.SIGNAL('outputChanged'), self) ## triggers flowchart to propagate new data", "self", ".", "sigOutputChanged", ".", "emit", "(", "self", ")" ]

[ "Returns", "a", "fully", "-", "qualified", "organization", "string", "." ]

[ "def", "common_organization_path", "(", "organization", ":", "str", ",", ")", "->", "str", ":", "return", "\"organizations/{organization}\"", ".", "format", "(", "organization", "=", "organization", ",", ")" ]

[ "Display", "the", "servers", "list", "." ]

[ "def", "display", "(", "self", ",", "stats", ",", "cs_status", "=", "None", ")", ":", "# Init the internal line/column for Glances Curses", "self", ".", "init_line_column", "(", ")", "# Get the current screen size", "screen_x", "=", "self", ".", "screen", ".", "getmaxyx", "(", ")", "[", "1", "]", "screen_y", "=", "self", ".", "screen", ".", "getmaxyx", "(", ")", "[", "0", "]", "stats_max", "=", "screen_y", "-", "3", "stats_len", "=", "len", "(", "stats", ")", "self", ".", "_page_max_lines", "=", "stats_max", "self", ".", "_page_max", "=", "int", "(", "math", ".", "ceil", "(", "stats_len", "/", "stats_max", ")", ")", "# Init position", "x", "=", "0", "y", "=", "0", "# Display top header", "if", "stats_len", "==", "0", ":", "if", "self", ".", "first_scan", "and", "not", "self", ".", "args", ".", "disable_autodiscover", ":", "msg", "=", "'Glances is scanning your network. Please wait...'", "self", ".", "first_scan", "=", "False", "else", ":", "msg", "=", "'No Glances server available'", "elif", "len", "(", "stats", ")", "==", "1", ":", "msg", "=", "'One Glances server available'", "else", ":", "msg", "=", "'{} Glances servers available'", ".", "format", "(", "stats_len", ")", "if", "self", ".", "args", ".", "disable_autodiscover", ":", "msg", "+=", "' (auto discover is disabled)'", "if", "screen_y", ">", "1", ":", "self", ".", "term_window", ".", "addnstr", "(", "y", ",", "x", ",", "msg", ",", "screen_x", "-", "x", ",", "self", ".", "colors_list", "[", "'TITLE'", "]", ")", "msg", "=", "'{}'", ".", "format", "(", "self", ".", "_get_status_count", "(", "stats", ")", ")", "self", ".", "term_window", ".", "addnstr", "(", "y", "+", "1", ",", "x", ",", "msg", ",", "screen_x", "-", "x", ")", "if", "stats_len", ">", "stats_max", "and", "screen_y", ">", "2", ":", "msg", "=", "'{} servers displayed.({}/{}) {}'", ".", "format", "(", "self", ".", "get_pagelines", "(", "stats", ")", ",", "self", ".", "_current_page", "+", "1", ",", "self", ".", "_page_max", ",", "self", ".", "_get_status_count", "(", "stats", ")", ")", "self", ".", "term_window", ".", "addnstr", "(", "y", "+", "1", ",", "x", ",", "msg", ",", "screen_x", "-", "x", ")", "if", "stats_len", "==", "0", ":", "return", "False", "# Display the Glances server list", "# ================================", "# Table of table", "# Item description: [stats_id, column name, column size]", "column_def", "=", "[", "[", "'name'", ",", "'Name'", ",", "16", "]", ",", "[", "'alias'", ",", "None", ",", "None", "]", ",", "[", "'load_min5'", ",", "'LOAD'", ",", "6", "]", ",", "[", "'cpu_percent'", ",", "'CPU%'", ",", "5", "]", ",", "[", "'mem_percent'", ",", "'MEM%'", ",", "5", "]", ",", "[", "'status'", ",", "'STATUS'", ",", "9", "]", ",", "[", "'ip'", ",", "'IP'", ",", "15", "]", ",", "# ['port', 'PORT', 5],", "[", "'hr_name'", ",", "'OS'", ",", "16", "]", ",", "]", "y", "=", "2", "# Display table header", "xc", "=", "x", "+", "2", "for", "cpt", ",", "c", "in", "enumerate", "(", "column_def", ")", ":", "if", "xc", "<", "screen_x", "and", "y", "<", "screen_y", "and", "c", "[", "1", "]", "is", "not", "None", ":", "self", ".", "term_window", ".", "addnstr", "(", "y", ",", "xc", ",", "c", "[", "1", "]", ",", "screen_x", "-", "x", ",", "self", ".", "colors_list", "[", "'BOLD'", "]", ")", "xc", "+=", "c", "[", "2", "]", "+", "self", ".", "space_between_column", "y", "+=", "1", "# If a servers has been deleted from the list...", "# ... and if the cursor is in the latest position", "if", "self", ".", "cursor", ">", "len", "(", "stats", ")", "-", "1", ":", "# Set the cursor position to the latest item", "self", ".", "cursor", "=", "len", "(", "stats", ")", "-", "1", "stats_list", "=", "self", ".", "_get_stats", "(", "stats", ")", "start_line", "=", "self", ".", "_page_max_lines", "*", "self", ".", "_current_page", "end_line", "=", "start_line", "+", "self", ".", "get_pagelines", "(", "stats_list", ")", "current_page", "=", "stats_list", "[", "start_line", ":", "end_line", "]", "# Display table", "line", "=", "0", "for", "v", "in", "current_page", ":", "# Limit the number of displayed server (see issue #1256)", "if", "line", ">=", "stats_max", ":", "continue", "# Get server stats", "server_stat", "=", "{", "}", "for", "c", "in", "column_def", ":", "try", ":", "server_stat", "[", "c", "[", "0", "]", "]", "=", "v", "[", "c", "[", "0", "]", "]", "except", "KeyError", "as", "e", ":", "logger", ".", "debug", "(", "\"Cannot grab stats {} from server (KeyError: {})\"", ".", "format", "(", "c", "[", "0", "]", ",", "e", ")", ")", "server_stat", "[", "c", "[", "0", "]", "]", "=", "'?'", "# Display alias instead of name", "try", ":", "if", "c", "[", "0", "]", "==", "'alias'", "and", "v", "[", "c", "[", "0", "]", "]", "is", "not", "None", ":", "server_stat", "[", "'name'", "]", "=", "v", "[", "c", "[", "0", "]", "]", "except", "KeyError", ":", "pass", "# Display line for server stats", "cpt", "=", "0", "xc", "=", "x", "# Is the line selected ?", "if", "line", "==", "self", ".", "cursor", ":", "# Display cursor", "self", ".", "term_window", ".", "addnstr", "(", "y", ",", "xc", ",", "\">\"", ",", "screen_x", "-", "xc", ",", "self", ".", "colors_list", "[", "'BOLD'", "]", ")", "# Display the line", "xc", "+=", "2", "for", "c", "in", "column_def", ":", "if", "xc", "<", "screen_x", "and", "y", "<", "screen_y", "and", "c", "[", "1", "]", "is", "not", "None", ":", "# Display server stats", "self", ".", "term_window", ".", "addnstr", "(", "y", ",", "xc", ",", "format", "(", "server_stat", "[", "c", "[", "0", "]", "]", ")", ",", "c", "[", "2", "]", ",", "self", ".", "colors_list", "[", "v", "[", "'status'", "]", "]", ")", "xc", "+=", "c", "[", "2", "]", "+", "self", ".", "space_between_column", "cpt", "+=", "1", "# Next line, next server...", "y", "+=", "1", "line", "+=", "1", "return", "True" ]

[]

[ "def", "publishers_type__from_string", "(", "xml_string", ")", ":", "return", "saml2", ".", "create_class_from_xml_string", "(", "PublishersType_", ",", "xml_string", ")" ]

[ "*", "this", "is", "an", "internal", "non", "-", "public", "method", "*" ]

[ "def", "_create_from_codes", "(", "self", ",", "codes", ",", "categories", "=", "None", ",", "ordered", "=", "None", ",", "name", "=", "None", ")", ":", "from", "pandas", ".", "core", ".", "categorical", "import", "Categorical", "if", "categories", "is", "None", ":", "categories", "=", "self", ".", "categories", "if", "ordered", "is", "None", ":", "ordered", "=", "self", ".", "ordered", "if", "name", "is", "None", ":", "name", "=", "self", ".", "name", "cat", "=", "Categorical", ".", "from_codes", "(", "codes", ",", "categories", "=", "categories", ",", "ordered", "=", "self", ".", "ordered", ")", "return", "CategoricalIndex", "(", "cat", ",", "name", "=", "name", ")" ]

[ "The", "user", "version", "of", "this", "database" ]

[ "def", "user_version", "(", "self", ")", ":", "return", "self", ".", "conn", ".", "get", "(", "'pragma user_version;'", ",", "all", "=", "False", ")" ]

[ "Creates", "a", "Query", "Parser", "." ]

[ "def", "CreateParser", "(", "query", ")", ":", "input_string", "=", "antlr3", ".", "ANTLRStringStream", "(", "query", ")", "lexer", "=", "QueryLexerWithErrors", "(", "input_string", ")", "tokens", "=", "antlr3", ".", "CommonTokenStream", "(", "lexer", ")", "parser", "=", "QueryParserWithErrors", "(", "tokens", ")", "return", "parser" ]

[ "Gets", "the", "replicas", "of", "this", "AppsV1beta1DeploymentStatus", ".", "Total", "number", "of", "non", "-", "terminated", "pods", "targeted", "by", "this", "deployment", "(", "their", "labels", "match", "the", "selector", ")", "." ]

[ "def", "replicas", "(", "self", ")", ":", "return", "self", ".", "_replicas" ]

[ ":", "return", ":", "Returns", "the", "domain", "name", "for", "the", "url", "." ]

[ "def", "get_protocol", "(", "self", ")", ":", "return", "self", ".", "_scheme" ]

[]

[ "def", "get_preprocess_type", "(", "self", ")", ":", "if", "(", "'conf'", "not", "in", "self", ".", "__dict__", ")", ":", "self", ".", "conf", "=", "self", ".", "get_view_obj", "(", "self", ".", "key", ")", "return", "self", ".", "conf", "[", "'preprocess'", "]" ]

[ "Second", "pairing", "step", "." ]

[ "def", "step2", "(", "self", ",", "atv_pub_key", ",", "atv_salt", ")", ":", "pk_str", "=", "binascii", ".", "hexlify", "(", "atv_pub_key", ")", ".", "decode", "(", ")", "salt", "=", "binascii", ".", "hexlify", "(", "atv_salt", ")", ".", "decode", "(", ")", "self", ".", "_session", ".", "process", "(", "pk_str", ",", "salt", ")", "if", "not", "self", ".", "_session", ".", "verify_proof", "(", "self", ".", "_session", ".", "key_proof_hash", ")", ":", "raise", "exceptions", ".", "AuthenticationError", "(", "\"proofs do not match\"", ")", "pub_key", "=", "binascii", ".", "unhexlify", "(", "self", ".", "_session", ".", "public", ")", "proof", "=", "binascii", ".", "unhexlify", "(", "self", ".", "_session", ".", "key_proof", ")", "log_binary", "(", "_LOGGER", ",", "\"Client\"", ",", "Public", "=", "pub_key", ",", "Proof", "=", "proof", ")", "return", "pub_key", ",", "proof" ]

[ "Sets", "the", "selector", "of", "this", "V1beta1ReplicaSetSpec", ".", "Selector", "is", "a", "label", "query", "over", "pods", "that", "should", "match", "the", "replica", "count", ".", "If", "the", "selector", "is", "empty", "it", "is", "defaulted", "to", "the", "labels", "present", "on", "the", "pod", "template", ".", "Label", "keys", "and", "values", "that", "must", "match", "in", "order", "to", "be", "controlled", "by", "this", "replica", "set", ".", "More", "info", ":", "https", ":", "//", "kubernetes", ".", "io", "/", "docs", "/", "concepts", "/", "overview", "/", "working", "-", "with", "-", "objects", "/", "labels", "/", "#label", "-", "selectors" ]

[ "def", "selector", "(", "self", ",", "selector", ")", ":", "self", ".", "_selector", "=", "selector" ]

[ "Returns", "the", "difference", "of", "the", "geometries" ]

[ "def", "difference", "(", "self", ",", "other", ")", ":", "return", "geom_factory", "(", "self", ".", "impl", "[", "'difference'", "]", "(", "self", ",", "other", ")", ")" ]

[ "Record", "-", "PLOADX1", "(", "7309", "73", "351", ")" ]

[ "def", "_read_ploadx1", "(", "self", ",", "data", ":", "bytes", ",", "n", ":", "int", ")", "->", "int", ":", "op2", "=", "self", ".", "op2", "ntotal", "=", "28", "# 7*4", "nentries", "=", "(", "len", "(", "data", ")", "-", "n", ")", "//", "ntotal", "struc", "=", "Struct", "(", "op2", ".", "_endian", "+", "b'2i2f iif'", ")", "for", "unused_i", "in", "range", "(", "nentries", ")", ":", "edata", "=", "data", "[", "n", ":", "n", "+", "28", "]", "out", "=", "struc", ".", "unpack", "(", "edata", ")", "if", "op2", ".", "is_debug_file", ":", "op2", ".", "binary_debug", ".", "write", "(", "' PLOADX1=%s\\n'", "%", "str", "(", "out", ")", ")", "load", "=", "PLOADX1", ".", "add_op2_data", "(", "out", ")", "op2", ".", "_add_methods", ".", "_add_load_object", "(", "load", ")", "n", "+=", "28", "op2", ".", "card_count", "[", "'PLOADX1'", "]", "=", "nentries", "return", "n" ]

[ "Emit", "a", "record", "." ]

[ "def", "emit", "(", "self", ",", "record", ")", ":", "self", ".", "reopenIfNeeded", "(", ")", "logging", ".", "FileHandler", ".", "emit", "(", "self", ",", "record", ")" ]

[]

[ "def", "_read", "(", "self", ",", "size", ")", ":", "return", "self", ".", "channel", ".", "recv", "(", "size", ")" ]

[ "A", "port", "of", "MATLAB", "s", "procrustes", "function", "to", "Numpy", ".", "Adapted", "from", "http", ":", "//", "stackoverflow", ".", "com", "/", "a", "/", "18927641", "/", "1884420" ]

[ "def", "compute_similarity_transform", "(", "X", ",", "Y", ",", "compute_optimal_scale", "=", "False", ")", ":", "muX", "=", "X", ".", "mean", "(", "0", ")", "muY", "=", "Y", ".", "mean", "(", "0", ")", "X0", "=", "X", "-", "muX", "Y0", "=", "Y", "-", "muY", "ssX", "=", "(", "X0", "**", "2.", ")", ".", "sum", "(", ")", "ssY", "=", "(", "Y0", "**", "2.", ")", ".", "sum", "(", ")", "# centred Frobenius norm", "normX", "=", "np", ".", "sqrt", "(", "ssX", ")", "normY", "=", "np", ".", "sqrt", "(", "ssY", ")", "# scale to equal (unit) norm", "X0", "=", "X0", "/", "normX", "Y0", "=", "Y0", "/", "normY", "# optimum rotation matrix of Y", "A", "=", "np", ".", "dot", "(", "X0", ".", "T", ",", "Y0", ")", "U", ",", "s", ",", "Vt", "=", "np", ".", "linalg", ".", "svd", "(", "A", ",", "full_matrices", "=", "False", ")", "V", "=", "Vt", ".", "T", "T", "=", "np", ".", "dot", "(", "V", ",", "U", ".", "T", ")", "# Make sure we have a rotation", "detT", "=", "np", ".", "linalg", ".", "det", "(", "T", ")", "V", "[", ":", ",", "-", "1", "]", "*=", "np", ".", "sign", "(", "detT", ")", "s", "[", "-", "1", "]", "*=", "np", ".", "sign", "(", "detT", ")", "T", "=", "np", ".", "dot", "(", "V", ",", "U", ".", "T", ")", "traceTA", "=", "s", ".", "sum", "(", ")", "if", "compute_optimal_scale", ":", "# Compute optimum scaling of Y.", "b", "=", "traceTA", "*", "normX", "/", "normY", "d", "=", "1", "-", "traceTA", "**", "2", "Z", "=", "normX", "*", "traceTA", "*", "np", ".", "dot", "(", "Y0", ",", "T", ")", "+", "muX", "else", ":", "# If no scaling allowed", "b", "=", "1", "d", "=", "1", "+", "ssY", "/", "ssX", "-", "2", "*", "traceTA", "*", "normY", "/", "normX", "Z", "=", "normY", "*", "np", ".", "dot", "(", "Y0", ",", "T", ")", "+", "muX", "c", "=", "muX", "-", "b", "*", "np", ".", "dot", "(", "muY", ",", "T", ")", "return", "d", ",", "Z", ",", "T", ",", "b", ",", "c" ]

[ "Return", "the", "maximum", "number", "of", "bits", "that", "can", "be", "encrypted" ]

[ "def", "size", "(", "self", ")", ":", "return", "size", "(", "self", ".", "p", ")", "-", "1" ]

[ "Forcibly", "close", "the", "websocket", ";", "generally", "it", "is", "preferable", "to", "return", "from", "the", "handler", "method", "." ]

[ "def", "close", "(", "self", ",", "close_data", "=", "None", ")", ":", "try", ":", "self", ".", "_send_closing_frame", "(", "close_data", "=", "close_data", ",", "ignore_send_errors", "=", "True", ")", "self", ".", "socket", ".", "shutdown", "(", "socket", ".", "SHUT_WR", ")", "except", "SocketError", "as", "e", ":", "if", "e", ".", "errno", "!=", "errno", ".", "ENOTCONN", ":", "self", ".", "log", ".", "write", "(", "'{ctx} socket shutdown error: {e}'", ".", "format", "(", "ctx", "=", "self", ".", "log_context", ",", "e", "=", "e", ")", ")", "finally", ":", "self", ".", "socket", ".", "close", "(", ")" ]

[]

[ "def", "__getstate__", "(", "self", ")", ":", "return", "{", "'_parent'", ":", "self", ".", "_parent", ",", "'_row'", ":", "tuple", "(", "self", ")", "}" ]

[ "Reset", "the", "samples", "for", "a", "given", "condition", "defaulting", "to", "all", "conditions", ".", "Args", ":", "condition", ":", "Condition", "for", "which", "to", "reset", "samples", "." ]

[ "def", "clear_samples", "(", "self", ",", "condition", "=", "None", ")", ":", "if", "condition", "is", "None", ":", "self", ".", "_samples", "=", "[", "[", "]", "for", "_", "in", "range", "(", "self", ".", "_hyperparams", "[", "'conditions'", "]", ")", "]", "else", ":", "self", ".", "_samples", "[", "condition", "]", "=", "[", "]" ]

[ "Python", "calls", "this", "hook", "to", "reload", "a", "module", "." ]

[ "def", "_reload_hook", "(", "self", ",", "module", ")", ":", "# reloading of a module may or may not be possible (depending on the", "# importer), but at least we can validate that it's ours to reload", "importer", "=", "module", ".", "__dict__", ".", "get", "(", "'__importer__'", ")", "if", "not", "importer", ":", "### oops. now what...", "pass", "# okay. it is using the imputil system, and we must delegate it, but", "# we don't know what to do (yet)", "### we should blast the module dict and do another get_code(). need to", "### flesh this out and add proper docco...", "raise", "SystemError", ",", "\"reload not yet implemented\"" ]

[ "Iterate", "over", "all", "(", "image", "label", ")", "pairs" ]

[ "def", "images", "(", ")", ":", "for", "ci", ",", "cl", "in", "enumerate", "(", "classes", ")", ":", "images", "=", "glob", "(", "'{}/{}/*.jpg'", ".", "format", "(", "basedir", ",", "cl", ")", ")", "for", "im", "in", "sorted", "(", "images", ")", ":", "yield", "im", ",", "ci" ]

[]

[ "def", "getPrivileges", "(", "self", ",", "*", "args", ")", ":", "warnMsg", "=", "\"on Microsoft Access it is not possible to enumerate the user privileges\"", "logger", ".", "warn", "(", "warnMsg", ")", "return", "{", "}" ]

[ "Write", "the", "current", "state", "of", "the", "database", "to", "the", "storage", "." ]

[ "def", "write", "(", "self", ",", "data", ":", "Dict", "[", "str", ",", "Dict", "[", "str", ",", "Any", "]", "]", ")", "->", "None", ":", "raise", "NotImplementedError", "(", "'To be overridden!'", ")" ]

[]

[ "def", "name", "(", "self", ")", ":", "return", "self", ".", "_name" ]

[ "Check", "if", "the", "union", "tag", "is", "group_add_external_id", "." ]

[ "def", "is_group_add_external_id", "(", "self", ")", ":", "return", "self", ".", "_tag", "==", "'group_add_external_id'" ]

[ "initialize", "module", "by", "setting", "soft", "-", "chroot", "-", "directory" ]

[ "def", "initialize", "(", "self", ",", "chdir", ")", ":", "orig_chdir", "=", "chdir", "if", "chdir", ":", "chdir", "=", "chdir", ".", "strip", "(", ")", "if", "(", "chdir", ")", ":", "# enabling soft-chroot:", "if", "not", "os", ".", "path", ".", "isdir", "(", "chdir", ")", ":", "raise", "SoftChrootInitError", "(", "2", ",", "'SOFT-CHROOT is requested, but the folder doesn\\'t exist'", ",", "orig_chdir", ")", "self", ".", "enabled", "=", "True", "self", ".", "chdir", "=", "chdir", ".", "rstrip", "(", "os", ".", "path", ".", "sep", ")", "+", "os", ".", "path", ".", "sep", "else", ":", "self", ".", "enabled", "=", "False" ]

[ "Return", "the", "column", "of", "the", "given", "name", "." ]

[ "def", "__getitem__", "(", "self", ",", "name", ")", ":", "return", "self", ".", "_columns", "[", "name", "]", ".", "data" ]

[ "Write", "a", "block", "of", "data", "to", "the", "file", "." ]

[ "def", "write_data_block", "(", "self", ",", "desc_block", ",", "data", ")", ":", "serialized_desc", "=", "desc_block", ".", "SerializeToString", "(", ")", "self", ".", "_write_block_header", "(", "DATA_BLOCK_TYPE", ",", "len", "(", "data", ")", "+", "len", "(", "serialized_desc", ")", ")", "self", ".", "_write", "(", "struct", ".", "pack", "(", "'<I'", ",", "len", "(", "serialized_desc", ")", ")", ")", "self", ".", "_write", "(", "serialized_desc", ")", "self", ".", "_write", "(", "data", ")" ]

[ "Appends", "some", "data", "to", "end", "of", "the", "buffer", "(", "right", ")", "." ]

[ "def", "append", "(", "self", ",", "data", ")", ":", "self", ".", "_append", "(", "data", ",", "True", ")" ]

[ "Generate", "Submission", "objects", "for", "each", "item", "provided", "in", "fullnames", "." ]

[ "def", "get_submissions", "(", "self", ",", "fullnames", ",", "*", "args", ",", "*", "*", "kwargs", ")", ":", "fullnames", "=", "fullnames", "[", ":", "]", "while", "fullnames", ":", "cur", "=", "fullnames", "[", ":", "100", "]", "fullnames", "[", ":", "100", "]", "=", "[", "]", "url", "=", "self", ".", "config", "[", "'by_id'", "]", "+", "','", ".", "join", "(", "cur", ")", "for", "item", "in", "self", ".", "get_content", "(", "url", ",", "limit", "=", "len", "(", "cur", ")", ",", "*", "args", ",", "*", "*", "kwargs", ")", ":", "yield", "item" ]

[ "Download", "a", "dataset", "from", "the", "source", "web", "-", "site" ]

[ "def", "download", "(", "self", ",", "path", ")", ":", "self", ".", "download_archive", "(", "path", ")", "with", "tarfile", ".", "open", "(", "self", ".", "localname", ",", "\"r\"", ")", "as", "archive", ":", "d", "=", "defaultdict", "(", "list", ")", "class_files", "=", "[", "os", ".", "path", ".", "join", "(", "self", ".", "SETS_PATH", ",", "self", ".", "task", ",", "name", ".", "replace", "(", "' '", ",", "''", ")", ")", "+", "'_trainval.txt'", "for", "name", "in", "self", ".", "classes", "]", "for", "class_file", "in", "class_files", ":", "data", "=", "archive", ".", "extractfile", "(", "class_file", ")", ".", "read", "(", ")", "for", "row", "in", "data", ".", "decode", "(", ")", ".", "split", "(", "'\\n'", ")", "[", ":", "-", "1", "]", ":", "key", "=", "row", ".", "split", "(", ")", "[", "0", "]", "value", "=", "int", "(", "row", ".", "split", "(", ")", "[", "1", "]", ")", "d", "[", "key", "]", ".", "append", "(", "value", ")", "train_ids", "=", "self", ".", "_extract_ids", "(", "archive", ",", "'train'", ")", "test_ids", "=", "self", ".", "_extract_ids", "(", "archive", ",", "'val'", ")", "images", "=", "np", ".", "array", "(", "[", "self", ".", "_extract_image", "(", "archive", ",", "self", ".", "_image_path", "(", "name", ")", ")", "for", "name", "in", "[", "*", "train_ids", ",", "*", "test_ids", "]", "]", ",", "dtype", "=", "object", ")", "targets", "=", "np", ".", "array", "(", "[", "d", "[", "self", ".", "_name", "(", "name", ")", "]", "for", "name", "in", "[", "*", "train_ids", ",", "*", "test_ids", "]", "]", ")", "labels", "=", "self", ".", "_process_targets", "(", "targets", ")", "preloaded", "=", "images", ",", "labels", "train_len", ",", "test_len", "=", "len", "(", "train_ids", ")", ",", "len", "(", "test_ids", ")", "index", ",", "train_index", ",", "test_index", "=", "self", ".", "_infer_train_test_index", "(", "train_len", ",", "test_len", ")", "return", "preloaded", ",", "index", ",", "train_index", ",", "test_index" ]

[ "Function", "path", ":", "DOM", ".", "disable", "Domain", ":", "DOM", "Method", "name", ":", "disable", "No", "return", "value", ".", "Description", ":", "Disables", "DOM", "agent", "for", "the", "given", "page", "." ]

[ "def", "DOM_disable", "(", "self", ")", ":", "subdom_funcs", "=", "self", ".", "synchronous_command", "(", "'DOM.disable'", ")", "return", "subdom_funcs" ]

[ "Compute", "the", "necessary", "table", "joins", "for", "the", "passage", "through", "the", "fields", "given", "in", "names", ".", "opts", "is", "the", "Options", "class", "for", "the", "current", "model", "(", "which", "gives", "the", "table", "we", "are", "joining", "to", ")", "alias", "is", "the", "alias", "for", "the", "table", "we", "are", "joining", "to", ".", "If", "dupe_multis", "is", "True", "any", "many", "-", "to", "-", "many", "or", "many", "-", "to", "-", "one", "joins", "will", "always", "create", "a", "new", "alias", "(", "necessary", "for", "disjunctive", "filters", ")", ".", "If", "can_reuse", "is", "not", "None", "it", "s", "a", "list", "of", "aliases", "that", "can", "be", "reused", "in", "these", "joins", "(", "nothing", "else", "can", "be", "reused", "in", "this", "case", ")", ".", "Finally", "negate", "is", "used", "in", "the", "same", "sense", "as", "for", "add_filter", "()", "--", "it", "indicates", "an", "exclude", "()", "filter", "or", "something", "similar", ".", "It", "is", "only", "passed", "in", "here", "so", "that", "it", "can", "be", "passed", "to", "a", "field", "s", "extra_filter", "()", "for", "customized", "behavior", "." ]

[ "def", "setup_joins", "(", "self", ",", "names", ",", "opts", ",", "alias", ",", "dupe_multis", ",", "allow_many", "=", "True", ",", "allow_explicit_fk", "=", "False", ",", "can_reuse", "=", "None", ",", "negate", "=", "False", ",", "process_extras", "=", "True", ")", ":", "joins", "=", "[", "alias", "]", "last", "=", "[", "0", "]", "dupe_set", "=", "set", "(", ")", "exclusions", "=", "set", "(", ")", "extra_filters", "=", "[", "]", "int_alias", "=", "None", "for", "pos", ",", "name", "in", "enumerate", "(", "names", ")", ":", "if", "int_alias", "is", "not", "None", ":", "exclusions", ".", "add", "(", "int_alias", ")", "exclusions", ".", "add", "(", "alias", ")", "last", ".", "append", "(", "len", "(", "joins", ")", ")", "if", "name", "==", "'pk'", ":", "name", "=", "opts", ".", "pk", ".", "name", "try", ":", "field", ",", "model", ",", "direct", ",", "m2m", "=", "opts", ".", "get_field_by_name", "(", "name", ")", "except", "FieldDoesNotExist", ":", "for", "f", "in", "opts", ".", "fields", ":", "if", "allow_explicit_fk", "and", "name", "==", "f", ".", "attname", ":", "# XXX: A hack to allow foo_id to work in values() for", "# backwards compatibility purposes. If we dropped that", "# feature, this could be removed.", "field", ",", "model", ",", "direct", ",", "m2m", "=", "opts", ".", "get_field_by_name", "(", "f", ".", "name", ")", "break", "else", ":", "names", "=", "opts", ".", "get_all_field_names", "(", ")", "+", "list", "(", "self", ".", "aggregate_select", ")", "raise", "FieldError", "(", "\"Cannot resolve keyword %r into field. \"", "\"Choices are: %s\"", "%", "(", "name", ",", "\", \"", ".", "join", "(", "names", ")", ")", ")", "if", "not", "allow_many", "and", "(", "m2m", "or", "not", "direct", ")", ":", "for", "alias", "in", "joins", ":", "self", ".", "unref_alias", "(", "alias", ")", "raise", "MultiJoin", "(", "pos", "+", "1", ")", "if", "model", ":", "# The field lives on a base class of the current model.", "# Skip the chain of proxy to the concrete proxied model", "proxied_model", "=", "opts", ".", "concrete_model", "for", "int_model", "in", "opts", ".", "get_base_chain", "(", "model", ")", ":", "if", "int_model", "is", "proxied_model", ":", "opts", "=", "int_model", ".", "_meta", "else", ":", "lhs_col", "=", "opts", ".", "parents", "[", "int_model", "]", ".", "column", "dedupe", "=", "lhs_col", "in", "opts", ".", "duplicate_targets", "if", "dedupe", ":", "exclusions", ".", "update", "(", "self", ".", "dupe_avoidance", ".", "get", "(", "(", "id", "(", "opts", ")", ",", "lhs_col", ")", ",", "(", ")", ")", ")", "dupe_set", ".", "add", "(", "(", "opts", ",", "lhs_col", ")", ")", "opts", "=", "int_model", ".", "_meta", "alias", "=", "self", ".", "join", "(", "(", "alias", ",", "opts", ".", "db_table", ",", "lhs_col", ",", "opts", ".", "pk", ".", "column", ")", ",", "exclusions", "=", "exclusions", ")", "joins", ".", "append", "(", "alias", ")", "exclusions", ".", "add", "(", "alias", ")", "for", "(", "dupe_opts", ",", "dupe_col", ")", "in", "dupe_set", ":", "self", ".", "update_dupe_avoidance", "(", "dupe_opts", ",", "dupe_col", ",", "alias", ")", "cached_data", "=", "opts", ".", "_join_cache", ".", "get", "(", "name", ")", "orig_opts", "=", "opts", "dupe_col", "=", "direct", "and", "field", ".", "column", "or", "field", ".", "field", ".", "column", "dedupe", "=", "dupe_col", "in", "opts", ".", "duplicate_targets", "if", "dupe_set", "or", "dedupe", ":", "if", "dedupe", ":", "dupe_set", ".", "add", "(", "(", "opts", ",", "dupe_col", ")", ")", "exclusions", ".", "update", "(", "self", ".", "dupe_avoidance", ".", "get", "(", "(", "id", "(", "opts", ")", ",", "dupe_col", ")", ",", "(", ")", ")", ")", "if", "process_extras", "and", "hasattr", "(", "field", ",", "'extra_filters'", ")", ":", "extra_filters", ".", "extend", "(", "field", ".", "extra_filters", "(", "names", ",", "pos", ",", "negate", ")", ")", "if", "direct", ":", "if", "m2m", ":", "# Many-to-many field defined on the current model.", "if", "cached_data", ":", "(", "table1", ",", "from_col1", ",", "to_col1", ",", "table2", ",", "from_col2", ",", "to_col2", ",", "opts", ",", "target", ")", "=", "cached_data", "else", ":", "table1", "=", "field", ".", "m2m_db_table", "(", ")", "from_col1", "=", "opts", ".", "get_field_by_name", "(", "field", ".", "m2m_target_field_name", "(", ")", ")", "[", "0", "]", ".", "column", "to_col1", "=", "field", ".", "m2m_column_name", "(", ")", "opts", "=", "field", ".", "rel", ".", "to", ".", "_meta", "table2", "=", "opts", ".", "db_table", "from_col2", "=", "field", ".", "m2m_reverse_name", "(", ")", "to_col2", "=", "opts", ".", "get_field_by_name", "(", "field", ".", "m2m_reverse_target_field_name", "(", ")", ")", "[", "0", "]", ".", "column", "target", "=", "opts", ".", "pk", "orig_opts", ".", "_join_cache", "[", "name", "]", "=", "(", "table1", ",", "from_col1", ",", "to_col1", ",", "table2", ",", "from_col2", ",", "to_col2", ",", "opts", ",", "target", ")", "int_alias", "=", "self", ".", "join", "(", "(", "alias", ",", "table1", ",", "from_col1", ",", "to_col1", ")", ",", "dupe_multis", ",", "exclusions", ",", "nullable", "=", "True", ",", "reuse", "=", "can_reuse", ")", "if", "int_alias", "==", "table2", "and", "from_col2", "==", "to_col2", ":", "joins", ".", "append", "(", "int_alias", ")", "alias", "=", "int_alias", "else", ":", "alias", "=", "self", ".", "join", "(", "(", "int_alias", ",", "table2", ",", "from_col2", ",", "to_col2", ")", ",", "dupe_multis", ",", "exclusions", ",", "nullable", "=", "True", ",", "reuse", "=", "can_reuse", ")", "joins", ".", "extend", "(", "[", "int_alias", ",", "alias", "]", ")", "elif", "field", ".", "rel", ":", "# One-to-one or many-to-one field", "if", "cached_data", ":", "(", "table", ",", "from_col", ",", "to_col", ",", "opts", ",", "target", ")", "=", "cached_data", "else", ":", "opts", "=", "field", ".", "rel", ".", "to", ".", "_meta", "target", "=", "field", ".", "rel", ".", "get_related_field", "(", ")", "table", "=", "opts", ".", "db_table", "from_col", "=", "field", ".", "column", "to_col", "=", "target", ".", "column", "orig_opts", ".", "_join_cache", "[", "name", "]", "=", "(", "table", ",", "from_col", ",", "to_col", ",", "opts", ",", "target", ")", "alias", "=", "self", ".", "join", "(", "(", "alias", ",", "table", ",", "from_col", ",", "to_col", ")", ",", "exclusions", "=", "exclusions", ",", "nullable", "=", "self", ".", "is_nullable", "(", "field", ")", ")", "joins", ".", "append", "(", "alias", ")", "else", ":", "# Non-relation fields.", "target", "=", "field", "break", "else", ":", "orig_field", "=", "field", "field", "=", "field", ".", "field", "if", "m2m", ":", "# Many-to-many field defined on the target model.", "if", "cached_data", ":", "(", "table1", ",", "from_col1", ",", "to_col1", ",", "table2", ",", "from_col2", ",", "to_col2", ",", "opts", ",", "target", ")", "=", "cached_data", "else", ":", "table1", "=", "field", ".", "m2m_db_table", "(", ")", "from_col1", "=", "opts", ".", "get_field_by_name", "(", "field", ".", "m2m_reverse_target_field_name", "(", ")", ")", "[", "0", "]", ".", "column", "to_col1", "=", "field", ".", "m2m_reverse_name", "(", ")", "opts", "=", "orig_field", ".", "opts", "table2", "=", "opts", ".", "db_table", "from_col2", "=", "field", ".", "m2m_column_name", "(", ")", "to_col2", "=", "opts", ".", "get_field_by_name", "(", "field", ".", "m2m_target_field_name", "(", ")", ")", "[", "0", "]", ".", "column", "target", "=", "opts", ".", "pk", "orig_opts", ".", "_join_cache", "[", "name", "]", "=", "(", "table1", ",", "from_col1", ",", "to_col1", ",", "table2", ",", "from_col2", ",", "to_col2", ",", "opts", ",", "target", ")", "int_alias", "=", "self", ".", "join", "(", "(", "alias", ",", "table1", ",", "from_col1", ",", "to_col1", ")", ",", "dupe_multis", ",", "exclusions", ",", "nullable", "=", "True", ",", "reuse", "=", "can_reuse", ")", "alias", "=", "self", ".", "join", "(", "(", "int_alias", ",", "table2", ",", "from_col2", ",", "to_col2", ")", ",", "dupe_multis", ",", "exclusions", ",", "nullable", "=", "True", ",", "reuse", "=", "can_reuse", ")", "joins", ".", "extend", "(", "[", "int_alias", ",", "alias", "]", ")", "else", ":", "# One-to-many field (ForeignKey defined on the target model)", "if", "cached_data", ":", "(", "table", ",", "from_col", ",", "to_col", ",", "opts", ",", "target", ")", "=", "cached_data", "else", ":", "local_field", "=", "opts", ".", "get_field_by_name", "(", "field", ".", "rel", ".", "field_name", ")", "[", "0", "]", "opts", "=", "orig_field", ".", "opts", "table", "=", "opts", ".", "db_table", "from_col", "=", "local_field", ".", "column", "to_col", "=", "field", ".", "column", "# In case of a recursive FK, use the to_field for", "# reverse lookups as well", "if", "orig_field", ".", "model", "is", "local_field", ".", "model", ":", "target", "=", "opts", ".", "get_field_by_name", "(", "field", ".", "rel", ".", "field_name", ")", "[", "0", "]", "else", ":", "target", "=", "opts", ".", "pk", "orig_opts", ".", "_join_cache", "[", "name", "]", "=", "(", "table", ",", "from_col", ",", "to_col", ",", "opts", ",", "target", ")", "alias", "=", "self", ".", "join", "(", "(", "alias", ",", "table", ",", "from_col", ",", "to_col", ")", ",", "dupe_multis", ",", "exclusions", ",", "nullable", "=", "True", ",", "reuse", "=", "can_reuse", ")", "joins", ".", "append", "(", "alias", ")", "for", "(", "dupe_opts", ",", "dupe_col", ")", "in", "dupe_set", ":", "if", "int_alias", "is", "None", ":", "to_avoid", "=", "alias", "else", ":", "to_avoid", "=", "int_alias", "self", ".", "update_dupe_avoidance", "(", "dupe_opts", ",", "dupe_col", ",", "to_avoid", ")", "if", "pos", "!=", "len", "(", "names", ")", "-", "1", ":", "if", "pos", "==", "len", "(", "names", ")", "-", "2", ":", "raise", "FieldError", "(", "\"Join on field %r not permitted. Did you misspell %r for the lookup type?\"", "%", "(", "name", ",", "names", "[", "pos", "+", "1", "]", ")", ")", "else", ":", "raise", "FieldError", "(", "\"Join on field %r not permitted.\"", "%", "name", ")", "return", "field", ",", "target", ",", "opts", ",", "joins", ",", "last", ",", "extra_filters" ]

[ "Returns", "self", "operand", "after", "adding", "the", "second", "value", "to", "its", "exp", "." ]

[ "def", "scaleb", "(", "self", ",", "other", ",", "context", "=", "None", ")", ":", "if", "context", "is", "None", ":", "context", "=", "getcontext", "(", ")", "other", "=", "_convert_other", "(", "other", ",", "raiseit", "=", "True", ")", "ans", "=", "self", ".", "_check_nans", "(", "other", ",", "context", ")", "if", "ans", ":", "return", "ans", "if", "other", ".", "_exp", "!=", "0", ":", "return", "context", ".", "_raise_error", "(", "InvalidOperation", ")", "liminf", "=", "-", "2", "*", "(", "context", ".", "Emax", "+", "context", ".", "prec", ")", "limsup", "=", "2", "*", "(", "context", ".", "Emax", "+", "context", ".", "prec", ")", "if", "not", "(", "liminf", "<=", "int", "(", "other", ")", "<=", "limsup", ")", ":", "return", "context", ".", "_raise_error", "(", "InvalidOperation", ")", "if", "self", ".", "_isinfinity", "(", ")", ":", "return", "Decimal", "(", "self", ")", "d", "=", "_dec_from_triple", "(", "self", ".", "_sign", ",", "self", ".", "_int", ",", "self", ".", "_exp", "+", "int", "(", "other", ")", ")", "d", "=", "d", ".", "_fix", "(", "context", ")", "return", "d" ]

[ "Provides", "the", "implementation", "of", "P_hash", "function", "defined", "in", "section", "5", "of", "RFC", "4346", "(", "and", "section", "5", "of", "RFC", "5246", ")", ".", "Two", "parameters", "have", "been", "added", "(", "hm", "and", "req_len", ")", ":" ]

[ "def", "_tls_P_hash", "(", "secret", ",", "seed", ",", "req_len", ",", "hm", ")", ":", "hash_len", "=", "hm", ".", "hash_alg", ".", "hash_len", "n", "=", "(", "req_len", "+", "hash_len", "-", "1", ")", "//", "hash_len", "seed", "=", "bytes_encode", "(", "seed", ")", "res", "=", "b\"\"", "a", "=", "hm", "(", "secret", ")", ".", "digest", "(", "seed", ")", "# A(1)", "while", "n", ">", "0", ":", "res", "+=", "hm", "(", "secret", ")", ".", "digest", "(", "a", "+", "seed", ")", "a", "=", "hm", "(", "secret", ")", ".", "digest", "(", "a", ")", "n", "-=", "1", "return", "res", "[", ":", "req_len", "]" ]

[ "Gets", "a", "cells", "feed", "or", "a", "specific", "entry", "if", "a", "cell", "is", "defined", "Args", ":", "key", ":", "string", "The", "spreadsheet", "key", "defined", "in", "/", "ccc?key", "=", "wksht_id", ":", "string", "The", "id", "for", "a", "specific", "worksheet", "entry", "cell", ":", "string", "(", "optional", ")", "The", "R1C1", "address", "of", "the", "cell", "query", ":", "DocumentQuery", "(", "optional", ")", "Query", "parameters", "Returns", ":", "If", "there", "is", "no", "cell", "then", "a", "SpreadsheetsCellsFeed", ".", "If", "there", "is", "a", "cell", "then", "a", "SpreadsheetsCell", "." ]

[ "def", "GetCellsFeed", "(", "self", ",", "key", ",", "wksht_id", "=", "'default'", ",", "cell", "=", "None", ",", "query", "=", "None", ",", "visibility", "=", "'private'", ",", "projection", "=", "'full'", ")", ":", "uri", "=", "(", "'https://%s/feeds/cells/%s/%s/%s/%s'", "%", "(", "self", ".", "server", ",", "key", ",", "wksht_id", ",", "visibility", ",", "projection", ")", ")", "if", "cell", "!=", "None", ":", "uri", "=", "'%s/%s'", "%", "(", "uri", ",", "cell", ")", "if", "query", "!=", "None", ":", "query", ".", "feed", "=", "uri", "uri", "=", "query", ".", "ToUri", "(", ")", "if", "cell", ":", "return", "self", ".", "Get", "(", "uri", ",", "converter", "=", "gdata", ".", "spreadsheet", ".", "SpreadsheetsCellFromString", ")", "else", ":", "return", "self", ".", "Get", "(", "uri", ",", "converter", "=", "gdata", ".", "spreadsheet", ".", "SpreadsheetsCellsFeedFromString", ")" ]

[ "Express", "the", "quantity", "in", "different", "units", ".", "If", "one", "unit", "is", "specified", "a", "new", "PhysicalQuantity", "object", "is", "returned", "that", "expresses", "the", "quantity", "in", "that", "unit", ".", "If", "several", "units", "are", "specified", "the", "return", "value", "is", "a", "tuple", "of", "PhysicalObject", "instances", "with", "with", "one", "element", "per", "unit", "such", "that", "the", "sum", "of", "all", "quantities", "in", "the", "tuple", "equals", "the", "original", "quantity", "and", "all", "the", "values", "except", "for", "the", "last", "one", "are", "integers", ".", "This", "is", "used", "to", "convert", "to", "irregular", "unit", "systems", "like", "hour", "/", "minute", "/", "second", "." ]

[ "def", "in_units_of", "(", "self", ",", "unit", ")", ":", "unit", "=", "_find_unit", "(", "unit", ")", "value", "=", "self", ".", "convert_value", "(", "unit", ")", "return", "self", ".", "__class__", "(", "value", ",", "unit", ")" ]