Datasets:

euclaise

/

thevault-filtered

like 2

[ "MIT" ]

[ "Write", "a", "function", "that", "accepts", "a", "list", "of", "strings", ".", "The", "list", "contains", "different", "words", ".", "Return", "the", "word", "with", "maximum", "number", "of", "unique", "characters", ".", "If", "multiple", "strings", "have", "maximum", "number", "of", "unique", "characters", "return", "the", "one", "which", "comes", "first", "in", "lexicographical", "order", "." ]

[ "def", "find_max", "(", "words", ")", ":", "return", "sorted", "(", "words", ",", "key", "=", "lambda", "x", ":", "(", "-", "len", "(", "set", "(", "x", ")", ")", ",", "x", ")", ")", "[", "0", "]" ]

[ "Write", "a", "function", "that", "accepts", "a", "list", "of", "strings", "." ]

[ "\"\"\"Write a function that accepts a list of strings.\n The list contains different words. Return the word with maximum number\n of unique characters. If multiple strings have maximum number of unique\n characters, return the one which comes first in lexicographical order.\n\n find_max([\"name\", \"of\", \"string\"]) == \"string\"\n find_max([\"name\", \"enam\", \"game\"]) == \"enam\"\n find_max([\"aaaaaaa\", \"bb\" ,\"cc\"]) == \"\"aaaaaaa\"\n \"\"\"", "#[SOLUTION]" ]

[ { "param": "words", "type": null } ]

{ "returns": [], "raises": [], "params": [ { "identifier": "words", "type": null, "docstring": null, "docstring_tokens": [], "default": null, "is_optional": null } ], "outlier_params": [], "others": [] }

[ "MIT" ]

[ "Run", "shell", "command", "and", "assert", "success", "exit", "code", "." ]

[ "def", "run_cmd", "(", "cmd", ",", "ret_code", "=", "0", ")", ":", "assert", "os", ".", "system", "(", "cmd", ")", "==", "ret_code" ]

[ "Run", "shell", "command", "and", "assert", "success", "exit", "code", "." ]

[ "\"\"\"\n Run shell command and assert success exit code.\n \"\"\"" ]

[ { "param": "cmd", "type": null }, { "param": "ret_code", "type": null } ]

{ "returns": [], "raises": [], "params": [ { "identifier": "cmd", "type": null, "docstring": null, "docstring_tokens": [], "default": null, "is_optional": null }, { "identifier": "ret_code", "type": null, "docstring": null, "docstring_tokens": [], "default": null, "is_optional": null } ], "outlier_params": [], "others": [] }

[ "MIT" ]

[ "Load", "file", "containing", "text", "parts", "to", "be", "used", "in", "tweet" ]

[ "def", "load_master_txt", "(", ")", ":", "if", "(", "os", ".", "environ", ".", "get", "(", "'DEV_ENV'", ",", "''", ")", "is", "\"1\"", ")", ":", "txt_file", "=", "open", "(", "\"../master.txt\"", ",", "\"r\"", ")", "else", ":", "txt_file", "=", "open", "(", "\"/txts/master/master.txt\"", ",", "\"r\"", ")", "txt", "=", "txt_file", ".", "read", "(", ")", "txt_parts", "=", "txt", ".", "split", "(", "'--'", ")", "split_on_newline", "=", "lambda", "l", ":", "l", ".", "split", "(", "\"\\n\"", ")", "non_empty", "=", "lambda", "s", ":", "len", "(", "s", ")", ">", "0", "filter_nonempty", "=", "lambda", "ls", ":", "list", "(", "filter", "(", "non_empty", ",", "ls", ")", ")", "break_apart_row", "=", "lambda", "row", ":", "{", "'title'", ":", "filter_nonempty", "(", "split_on_newline", "(", "row", ")", ")", "[", "0", "]", ",", "'body'", ":", "filter_nonempty", "(", "split_on_newline", "(", "row", ")", ")", "[", "1", "]", "}", "txt_parts", "=", "list", "(", "map", "(", "break_apart_row", ",", "txt_parts", ")", ")", "return", "txt_parts" ]

[ "Load", "file", "containing", "text", "parts", "to", "be", "used", "in", "tweet" ]

[ "\"\"\"Load file containing text parts to be used in tweet\"\"\"" ]

[]

{ "returns": [], "raises": [], "params": [], "outlier_params": [], "others": [] }

[ "MIT" ]

[ "Generate", "a", "random", "string", "of", "fixed", "length" ]

[ "def", "randomString", "(", "stringLength", "=", "5", ")", ":", "letters", "=", "string", ".", "ascii_lowercase", "return", "''", ".", "join", "(", "random", ".", "choice", "(", "letters", ")", "for", "i", "in", "range", "(", "stringLength", ")", ")" ]

[ "Generate", "a", "random", "string", "of", "fixed", "length" ]

[ "\"\"\"\n Generate a random string of fixed length\n \"\"\"" ]

[ { "param": "stringLength", "type": null } ]

{ "returns": [], "raises": [], "params": [ { "identifier": "stringLength", "type": null, "docstring": null, "docstring_tokens": [], "default": null, "is_optional": null } ], "outlier_params": [], "others": [] }

[ "MIT" ]

[ "Registers", "origin", "to", "be", "notified", "when", "an", "update", "occurs", "to", "its", "cache", "storage", "list", "." ]

[ "def", "trackCacheStorageForOrigin", "(", "cls", ",", "origin", ":", "Union", "[", "'str'", "]", ",", ")", ":", "return", "(", "cls", ".", "build_send_payload", "(", "\"trackCacheStorageForOrigin\"", ",", "{", "\"origin\"", ":", "origin", ",", "}", ")", ",", "None", ")" ]

[ "Registers", "origin", "to", "be", "notified", "when", "an", "update", "occurs", "to", "its", "cache", "storage", "list", "." ]

[ "\"\"\"Registers origin to be notified when an update occurs to its cache storage list.\n :param origin: Security origin.\n :type origin: str\n \"\"\"" ]

[ { "param": "cls", "type": null }, { "param": "origin", "type": "Union['str']" } ]

{ "returns": [], "raises": [], "params": [ { "identifier": "cls", "type": null, "docstring": null, "docstring_tokens": [], "default": null, "is_optional": null }, { "identifier": "origin", "type": "Union['str']", "docstring": null, "docstring_tokens": [ "None" ], "default": null, "is_optional": null } ], "outlier_params": [], "others": [] }

[ "Apache-2.0" ]

[ "Helper", "function", "to", "remove", "all", "triggers", "." ]

[ "def", "clear_triggers", "(", "server", ")", ":", "names", "=", "list", "(", "server", ".", "_triggers", ".", "keys", "(", ")", ")", "for", "name", "in", "names", ":", "fn", "=", "server", ".", "_triggers", ".", "pop", "(", "name", ")", "server", ".", "_triggers_fn2name", ".", "pop", "(", "fn", ")", "print", "(", "f\"unregister trigger {name}\"", ")" ]

[ "Helper", "function", "to", "remove", "all", "triggers", "." ]

[ "\"\"\"\n Helper function to remove all triggers.\n\n :param server: server on which we want to clear the triggers\n :type server: trame_server.core.Server\n \"\"\"" ]

[ { "param": "server", "type": null } ]

{ "returns": [], "raises": [], "params": [ { "identifier": "server", "type": null, "docstring": "server on which we want to clear the triggers", "docstring_tokens": [ "server", "on", "which", "we", "want", "to", "clear", "the", "triggers" ], "default": null, "is_optional": null } ], "outlier_params": [], "others": [] }

[ "Apache-2.0" ]

[ "Returns", "the", "path", "to", "the", "given", "executable", "or", "None", "if", "it", "is", "not", "found", ".", "This", "algorithm", "provides", "a", "reasonably", "accurate", "determination", "of", "whether", "or", "not", "the", "given", "executable", "is", "on", "the", "machine", "and", "can", "be", "used", "without", "knowing", "its", "full", "path", ".", "An", "optional", "path", "can", "be", "added", "to", "the", "search", ".", "The", "algorithm", "returns", "the", "path", "or", "None", "." ]

[ "def", "_GetExecutable", "(", "executable", ",", "location", "=", "None", ")", ":", "extensions", "=", "os", ".", "environ", ".", "get", "(", "'PATHEXT'", ",", "''", ")", ".", "split", "(", "os", ".", "pathsep", ")", "paths", "=", "os", ".", "environ", ".", "get", "(", "'PATH'", ",", "''", ")", ".", "split", "(", "os", ".", "pathsep", ")", "if", "location", ":", "paths", ".", "append", "(", "location", ")", "for", "extension", "in", "extensions", ":", "for", "path", "in", "paths", ":", "full_path", "=", "os", ".", "path", ".", "join", "(", "path", ",", "'%s%s'", "%", "(", "executable", ",", "extension", ")", ")", "if", "os", ".", "path", ".", "isfile", "(", "full_path", ")", "and", "os", ".", "access", "(", "full_path", ",", "os", ".", "X_OK", ")", ":", "return", "full_path", "return", "None" ]

[ "Returns", "the", "path", "to", "the", "given", "executable", "or", "None", "if", "it", "is", "not", "found", "." ]

[ "\"\"\"Returns the path to the given executable or None if it is not found.\n\n This algorithm provides a reasonably accurate determination of whether or\n not the given executable is on the machine and can be used without knowing\n its full path. An optional path can be added to the search. The algorithm\n returns the path or None.\n\n Args:\n executable: The name of the executable (no path info).(string)\n location: Optional location to search for the tool. (string)\n\n Returns:\n The path to the executable or None. (string)\n \"\"\"", "# Loop over every combination of path and file extension." ]

[ { "param": "executable", "type": null }, { "param": "location", "type": null } ]

{ "returns": [ { "docstring": "The path to the executable or None. (string)", "docstring_tokens": [ "The", "path", "to", "the", "executable", "or", "None", ".", "(", "string", ")" ], "type": null } ], "raises": [], "params": [ { "identifier": "executable", "type": null, "docstring": "The name of the executable (no path info).(string)", "docstring_tokens": [ "The", "name", "of", "the", "executable", "(", "no", "path", "info", ")", ".", "(", "string", ")" ], "default": null, "is_optional": null }, { "identifier": "location", "type": null, "docstring": "Optional location to search for the tool. (string)", "docstring_tokens": [ "Optional", "location", "to", "search", "for", "the", "tool", ".", "(", "string", ")" ], "default": null, "is_optional": null } ], "outlier_params": [], "others": [] }

[ "MIT" ]

[ "Extract", "bboxes", "from", "all", "classes", "and", "return", "a", "list", "of", "bbox", ".", "Each", "element", "of", "the", "list", "is", "in", "the", "form", ":", "[", "x1", "y1", "x2", "y2", "class_id", "score", "]", ".", "The", "returned", "list", "is", "sorted", "descendingly", "according", "to", "score", "." ]

[ "def", "formalize_bbox", "(", "_im_summary", ")", ":", "boxes", "=", "[", "]", "probs", "=", "[", "]", "feats", "=", "[", "]", "for", "class_id", ",", "items", "in", "enumerate", "(", "_im_summary", ".", "pred", ".", "boxes", ")", ":", "for", "bbox", "in", "items", ":", "x1", ",", "y1", ",", "x2", ",", "y2", ",", "score", "=", "bbox", "boxes", ".", "append", "(", "[", "x1", ",", "y1", ",", "x2", ",", "y2", ",", "class_id", ",", "score", "]", ")", "for", "class_id", ",", "items", "in", "enumerate", "(", "_im_summary", ".", "pred", ".", "cls_prob", ")", ":", "for", "cls_prob", "in", "items", ":", "probs", ".", "append", "(", "cls_prob", ")", "for", "class_id", ",", "items", "in", "enumerate", "(", "_im_summary", ".", "pred", ".", "pooled_feat", ")", ":", "for", "f", "in", "items", ":", "feats", ".", "append", "(", "f", ")", "assert", "len", "(", "boxes", ")", "==", "len", "(", "probs", ")", "assert", "len", "(", "boxes", ")", "==", "len", "(", "feats", ")", "bundles", "=", "list", "(", "zip", "(", "boxes", ",", "probs", ",", "feats", ")", ")", "bundles", "=", "sorted", "(", "bundles", ",", "key", "=", "lambda", "x", ":", "x", "[", "0", "]", "[", "-", "1", "]", ",", "reverse", "=", "True", ")", "boxes", ",", "probs", ",", "feats", "=", "zip", "(", "*", "bundles", ")", "return", "(", "list", "(", "boxes", ")", ",", "list", "(", "probs", ")", ",", "list", "(", "feats", ")", ")" ]

[ "Extract", "bboxes", "from", "all", "classes", "and", "return", "a", "list", "of", "bbox", "." ]

[ "\"\"\"\n Extract bboxes from all classes and return a list of bbox. \n Each element of the list is in the form: [x1, y1, x2, y2, class_id, score]. \n The returned list is sorted descendingly according to score. \n \"\"\"", "# each element: x, y, w, h, class_id, score ", "# prob distribution for each bounding box", "# pooled features", "# sort by confidence descendingly " ]

[ { "param": "_im_summary", "type": null } ]

{ "returns": [], "raises": [], "params": [ { "identifier": "_im_summary", "type": null, "docstring": null, "docstring_tokens": [], "default": null, "is_optional": null } ], "outlier_params": [], "others": [] }

[ "BSD-3-Clause" ]

[ "This", "function", "will", "display", "number", "of", "the", "how", "many", "bytes", "transfered", ".", "This", "function", "usefull", "for", "ftp", "sftp", "Internal", "modules", "inner", "callable", "functions", "." ]

[ "def", "transferedByteDisplay", "(", "fileName", ",", "bytesToFar", ",", "totalByte", ")", ":", "print", "(", "'Transfer of %r is at %d/%d bytes (%.1f%%)'", "%", "(", "fileName", ",", "bytesToFar", ",", "totalByte", ",", "100.", "*", "bytesToFar", "/", "totalByte", ")", ")" ]

[ "INFO", ":", "This", "function", "will", "display", "number", "of", "the", "how", "many", "bytes", "transfered", "." ]

[ "\"\"\"\n INFO: This function will display number of the how many bytes transfered. This function usefull for ftp, sftp\n Internal modules inner callable functions.\n :param fileName: Filename\n :param bytesToFar: The proceeded byte count\n :param totalByte: Total byte count of the filename\n :return: NONE\n \"\"\"" ]

[ { "param": "fileName", "type": null }, { "param": "bytesToFar", "type": null }, { "param": "totalByte", "type": null } ]

{ "returns": [ { "docstring": null, "docstring_tokens": [ "None" ], "type": null } ], "raises": [], "params": [ { "identifier": "fileName", "type": null, "docstring": null, "docstring_tokens": [ "None" ], "default": null, "is_optional": null }, { "identifier": "bytesToFar", "type": null, "docstring": "The proceeded byte count", "docstring_tokens": [ "The", "proceeded", "byte", "count" ], "default": null, "is_optional": null }, { "identifier": "totalByte", "type": null, "docstring": "Total byte count of the filename", "docstring_tokens": [ "Total", "byte", "count", "of", "the", "filename" ], "default": null, "is_optional": null } ], "outlier_params": [], "others": [] }

[ "MIT" ]

[ "Format", "a", "sequence", "element", "using", "FASTA", "format", "and", "k", "sequence", "length", "." ]

[ "def", "format_element", "(", "eid", ",", "eseq", ",", "k", ")", ":", "if", "k", ">", "0", ":", "eseq", "=", "[", "eseq", "[", "i", ":", "min", "(", "i", "+", "k", ",", "len", "(", "eseq", ")", ")", "]", "for", "i", "in", "range", "(", "0", ",", "len", "(", "eseq", ")", ",", "k", ")", "]", "eseq", "=", "\"\\n\"", ".", "join", "(", "eseq", ")", "return", "(", "\"> %s\\n%s\"", "%", "(", "eid", ",", "eseq", ")", ")" ]

[ "Format", "a", "sequence", "element", "using", "FASTA", "format", "and", "k", "sequence", "length", "." ]

[ "\"\"\"Format a sequence element using FASTA format and k sequence length.\n\n\tArgs:\n\t\teid (string): element ID.\n\t\teseq (string): element sequence.\n\t\tk (int): sequence line length.\n\n\tReturn:\n\t\tstring: \"> %s\\n%s\" % (eid, eseq_split_by_k)\n\t\"\"\"" ]

[ { "param": "eid", "type": null }, { "param": "eseq", "type": null }, { "param": "k", "type": null } ]

{ "returns": [], "raises": [], "params": [ { "identifier": "eid", "type": null, "docstring": null, "docstring_tokens": [ "None" ], "default": null, "is_optional": false }, { "identifier": "eseq", "type": null, "docstring": null, "docstring_tokens": [ "None" ], "default": null, "is_optional": false }, { "identifier": "k", "type": null, "docstring": "sequence line length.", "docstring_tokens": [ "sequence", "line", "length", "." ], "default": null, "is_optional": false } ], "outlier_params": [], "others": [] }

[ "MIT" ]

[ "Create", "a", "\"", "gt", "generator", "\"", ".", "This", "will", "be", "a", "copy", "of", "the", "model", "minus", "the", "shape", "configuration", ".", "It", "will", "be", "fixed", "throughout", "one", "epoch", "and", "will", "generate", "the", "ground", "truth", "to", "train", "the", "shape", "configuration", "model", ".", "This", "ground", "truth", "will", "be", "the", "pooling", "shape", "dimensions", "that", "yielded", "the", "lowest", "loss", "-", "simulating", "what", "could", "be", "the", "real", "shape", "dimension", "of", "the", "pedestrian", ".", "May", "also", "disable", "gradient", "computation", "for", "parts", "of", "the", "original", "model", "(", "that", "are", "not", "relevant", "from", "a", "point", "of", "view", "of", "training", ")", "." ]

[ "def", "create_gt_generator", "(", "model", ")", ":", "shape_config", "=", "model", ".", "shape_config", "model", ".", "shape_config", "=", "None", "gt_generator", "=", "copy", ".", "deepcopy", "(", "model", ")", "gt_generator", ".", "eval", "(", ")", "gt_generator", ".", "shape_config", "=", "None", "model", ".", "shape_config", "=", "shape_config", "for", "param", "in", "gt_generator", ".", "parameters", "(", ")", ":", "param", ".", "requires_grad", "=", "False", "for", "param", "in", "model", ".", "parameters", "(", ")", ":", "param", ".", "requires_grad", "=", "True", "interaction_module", "=", "copy", ".", "deepcopy", "(", "gt_generator", ".", "interaction_module", ")", "return", "gt_generator", ",", "interaction_module" ]

[ "Create", "a", "\"", "gt", "generator", "\"", "." ]

[ "\"\"\"\n Create a \"gt generator\". This will be a copy of the model, minus the shape configuration. It will be fixed\n throughout one epoch, and will generate the ground truth to train the shape configuration model. This ground truth\n will be the pooling shape dimensions that yielded the lowest loss - simulating what could be the real shape\n dimension of the pedestrian.\n May also disable gradient computation for parts of the original model (that are not relevant from a point of view\n of training).\n :param model: the original model\n :return: the gt generator, and the interaction model\n \"\"\"", "# gt_model a model that will be used to generate \"predictions\" that will be simulated as ground truth data", "# deepcopy might not work without this line, due to there being some extra tensors", "# disable all gradients - except for the ones associated to the shape configuration network", "# because the actual pooling data will come from a dataset, and not computed by the module, the goal of this", "# interaction module is just to embed the data, and send it as direct input to the LSTM cell" ]

[ { "param": "model", "type": null } ]

{ "returns": [ { "docstring": "the gt generator, and the interaction model", "docstring_tokens": [ "the", "gt", "generator", "and", "the", "interaction", "model" ], "type": null } ], "raises": [], "params": [ { "identifier": "model", "type": null, "docstring": "the original model", "docstring_tokens": [ "the", "original", "model" ], "default": null, "is_optional": null } ], "outlier_params": [], "others": [] }

[ "BSD-3-Clause" ]

[ "Part", "of", "SNIPPET", "10", ".", "4", "Calculates", "the", "inverse", "of", "the", "bet", "size", "with", "respect", "to", "the", "market", "price", ".", "Based", "on", "a", "sigmoid", "function", "for", "a", "bet", "size", "algorithm", "." ]

[ "def", "inv_price_sigmoid", "(", "forecast_price", ",", "w_param", ",", "m_bet_size", ")", ":", "return", "forecast_price", "-", "m_bet_size", "*", "(", "w_param", "/", "(", "1", "-", "m_bet_size", "**", "2", ")", ")", "**", "0.5" ]

[ "Part", "of", "SNIPPET", "10", ".", "4", "Calculates", "the", "inverse", "of", "the", "bet", "size", "with", "respect", "to", "the", "market", "price", "." ]

[ "\"\"\"\n Part of SNIPPET 10.4\n Calculates the inverse of the bet size with respect to the market price.\n Based on a sigmoid function for a bet size algorithm.\n\n :param forecast_price: (float) Forecast price.\n :param w_param: (float) Coefficient regulating the width of the bet size function.\n :param m_bet_size: (float) Bet size.\n :return: (float) Inverse of bet size with respect to market price.\n \"\"\"" ]

[ { "param": "forecast_price", "type": null }, { "param": "w_param", "type": null }, { "param": "m_bet_size", "type": null } ]

{ "returns": [ { "docstring": "(float) Inverse of bet size with respect to market price.", "docstring_tokens": [ "(", "float", ")", "Inverse", "of", "bet", "size", "with", "respect", "to", "market", "price", "." ], "type": null } ], "raises": [], "params": [ { "identifier": "forecast_price", "type": null, "docstring": "(float) Forecast price.", "docstring_tokens": [ "(", "float", ")", "Forecast", "price", "." ], "default": null, "is_optional": null }, { "identifier": "w_param", "type": null, "docstring": "(float) Coefficient regulating the width of the bet size function.", "docstring_tokens": [ "(", "float", ")", "Coefficient", "regulating", "the", "width", "of", "the", "bet", "size", "function", "." ], "default": null, "is_optional": null }, { "identifier": "m_bet_size", "type": null, "docstring": "(float) Bet size.", "docstring_tokens": [ "(", "float", ")", "Bet", "size", "." ], "default": null, "is_optional": null } ], "outlier_params": [], "others": [] }

[ "MIT" ]

[ "given", "idx", "return", "the", "averaged", "distributed", "levels" ]

[ "def", "sample_levels", "(", "training_level_set", ",", "num_agents", ",", "agent_idx", ")", ":", "n", "=", "math", ".", "ceil", "(", "len", "(", "training_level_set", ")", "/", "num_agents", ")", "total_list", "=", "[", "]", "for", "i", "in", "range", "(", "0", ",", "len", "(", "training_level_set", ")", ",", "n", ")", ":", "total_list", ".", "append", "(", "training_level_set", "[", "i", ":", "i", "+", "n", "]", ")", "if", "agent_idx", ">=", "len", "(", "total_list", ")", ":", "return", "None", "return", "total_list", "[", "agent_idx", "]" ]

[ "given", "idx", "return", "the", "averaged", "distributed", "levels" ]

[ "'''\n given idx, return the averaged distributed levels\n '''" ]

[ { "param": "training_level_set", "type": null }, { "param": "num_agents", "type": null }, { "param": "agent_idx", "type": null } ]

{ "returns": [], "raises": [], "params": [ { "identifier": "training_level_set", "type": null, "docstring": null, "docstring_tokens": [], "default": null, "is_optional": null }, { "identifier": "num_agents", "type": null, "docstring": null, "docstring_tokens": [], "default": null, "is_optional": null }, { "identifier": "agent_idx", "type": null, "docstring": null, "docstring_tokens": [], "default": null, "is_optional": null } ], "outlier_params": [], "others": [] }

[ "BSD-3-Clause" ]

[ "Returns", "the", "number", "of", "cells", "used", "in", "a", "tabular", "inline" ]

[ "def", "cell_count", "(", "inline_admin_form", ")", ":", "count", "=", "1", "for", "fieldset", "in", "inline_admin_form", ":", "for", "line", "in", "fieldset", ":", "for", "field", "in", "line", ":", "count", "+=", "1", "if", "inline_admin_form", ".", "formset", ".", "can_delete", ":", "count", "+=", "1", "return", "count" ]

[ "Returns", "the", "number", "of", "cells", "used", "in", "a", "tabular", "inline" ]

[ "\"\"\"Returns the number of cells used in a tabular inline\"\"\"", "# Hidden cell with hidden 'id' field", "# Loop through all the fields (one per cell)", "# Delete checkbox" ]

[ { "param": "inline_admin_form", "type": null } ]

{ "returns": [], "raises": [], "params": [ { "identifier": "inline_admin_form", "type": null, "docstring": null, "docstring_tokens": [], "default": null, "is_optional": null } ], "outlier_params": [], "others": [] }

[ "Apache-2.0" ]

[ "convert", "a", "example", "into", "necessary", "features" ]

[ "def", "convert_example", "(", "example", ",", "tokenizer", ",", "max_seq_length", "=", "256", ",", "language", "=", "\"en\"", ")", ":", "label", "=", "example", "[", "\"label\"", "]", "premise", "=", "example", "[", "\"premise\"", "]", "hypothesis", "=", "example", "[", "\"hypothesis\"", "]", "example", "=", "tokenizer", "(", "premise", ",", "text_pair", "=", "hypothesis", ",", "max_length", "=", "max_seq_length", ",", "return_attention_mask", "=", "True", ",", "return_token_type_ids", "=", "False", ",", "lang", "=", "language", ")", "return", "example", "[", "\"input_ids\"", "]", ",", "example", "[", "\"attention_mask\"", "]", ",", "label" ]

[ "convert", "a", "example", "into", "necessary", "features" ]

[ "\"\"\"convert a example into necessary features\"\"\"", "# Get the label", "# Convert raw text to feature" ]

[ { "param": "example", "type": null }, { "param": "tokenizer", "type": null }, { "param": "max_seq_length", "type": null }, { "param": "language", "type": null } ]

{ "returns": [], "raises": [], "params": [ { "identifier": "example", "type": null, "docstring": null, "docstring_tokens": [], "default": null, "is_optional": null }, { "identifier": "tokenizer", "type": null, "docstring": null, "docstring_tokens": [], "default": null, "is_optional": null }, { "identifier": "max_seq_length", "type": null, "docstring": null, "docstring_tokens": [], "default": null, "is_optional": null }, { "identifier": "language", "type": null, "docstring": null, "docstring_tokens": [], "default": null, "is_optional": null } ], "outlier_params": [], "others": [] }

[ "MIT" ]

[ "Extract", "values", "from", "0", "-", "d", "numpy", "arrays", "if", "necessary" ]

[ "def", "maybe_flatten", "(", "value", ")", ":", "if", "hasattr", "(", "value", ",", "\"shape\"", ")", "and", "not", "value", ".", "shape", ":", "return", "value", ".", "flatten", "(", ")", "[", "0", "]", "return", "value" ]

[ "Extract", "values", "from", "0", "-", "d", "numpy", "arrays", "if", "necessary" ]

[ "\"Extract values from 0-d numpy arrays, if necessary\"", "# 0-d numpy arrays" ]

[ { "param": "value", "type": null } ]

{ "returns": [], "raises": [], "params": [ { "identifier": "value", "type": null, "docstring": null, "docstring_tokens": [], "default": null, "is_optional": null } ], "outlier_params": [], "others": [] }

[ "MIT" ]

[ "Checks", "if", "two", "rows", "are", "similar", "enough", "to", "be", "mapped", "." ]

[ "def", "row_is_mappable", "(", "doc_row", ",", "return_doc_row", ",", "detail_field", ")", ":", "if", "doc_row", ".", "item_code", "==", "return_doc_row", ".", "item_code", "and", "not", "return_doc_row", ".", "get", "(", "detail_field", ")", ":", "if", "doc_row", ".", "get", "(", "'batch_no'", ")", "and", "return_doc_row", ".", "get", "(", "'batch_no'", ")", "and", "doc_row", ".", "batch_no", "==", "return_doc_row", ".", "batch_no", ":", "return", "True", "elif", "doc_row", ".", "get", "(", "'serial_no'", ")", "and", "return_doc_row", ".", "get", "(", "'serial_no'", ")", ":", "doc_sn", "=", "doc_row", ".", "serial_no", ".", "split", "(", "'\\n'", ")", "return_doc_sn", "=", "return_doc_row", ".", "serial_no", ".", "split", "(", "'\\n'", ")", "if", "set", "(", "doc_sn", ")", "&", "set", "(", "return_doc_sn", ")", ":", "return", "True", "elif", "doc_row", ".", "rate", "==", "return_doc_row", ".", "rate", ":", "return", "True", "else", ":", "return", "False" ]

[ "Checks", "if", "two", "rows", "are", "similar", "enough", "to", "be", "mapped", "." ]

[ "\"\"\"Checks if two rows are similar enough to be mapped.\"\"\"", "# if two rows have serial nos in common, map them" ]

[ { "param": "doc_row", "type": null }, { "param": "return_doc_row", "type": null }, { "param": "detail_field", "type": null } ]

{ "returns": [], "raises": [], "params": [ { "identifier": "doc_row", "type": null, "docstring": null, "docstring_tokens": [], "default": null, "is_optional": null }, { "identifier": "return_doc_row", "type": null, "docstring": null, "docstring_tokens": [], "default": null, "is_optional": null }, { "identifier": "detail_field", "type": null, "docstring": null, "docstring_tokens": [], "default": null, "is_optional": null } ], "outlier_params": [], "others": [] }

[ "MIT" ]

[ "Match", "a", "ground", "truth", "with", "every", "predictions", "and", "return", "matched", "index", "." ]

[ "def", "match_gt_with_preds", "(", "ground_truth", ",", "predictions", ",", "match_labels", ")", ":", "max_confidence", "=", "0.", "matched_idx", "=", "-", "1", "for", "i", ",", "pred", "in", "enumerate", "(", "predictions", ")", ":", "if", "match_labels", "(", "ground_truth", ",", "pred", "[", "1", "]", ")", "and", "max_confidence", "<", "pred", "[", "0", "]", ":", "max_confidence", "=", "pred", "[", "0", "]", "matched_idx", "=", "i", "return", "matched_idx" ]

[ "Match", "a", "ground", "truth", "with", "every", "predictions", "and", "return", "matched", "index", "." ]

[ "\"\"\"Match a ground truth with every predictions and return matched index.\"\"\"" ]

[ { "param": "ground_truth", "type": null }, { "param": "predictions", "type": null }, { "param": "match_labels", "type": null } ]

{ "returns": [], "raises": [], "params": [ { "identifier": "ground_truth", "type": null, "docstring": null, "docstring_tokens": [], "default": null, "is_optional": null }, { "identifier": "predictions", "type": null, "docstring": null, "docstring_tokens": [], "default": null, "is_optional": null }, { "identifier": "match_labels", "type": null, "docstring": null, "docstring_tokens": [], "default": null, "is_optional": null } ], "outlier_params": [], "others": [] }

[ "MIT" ]

[ "Calls", "the", "given", "function", "on", "every", "element", "on", "the", "given", "array", "and", "returns", "the", "resulting", "elements", "." ]

[ "def", "map_array", "(", "func", ",", "arr", ":", "list", ")", "->", "list", ":", "res", "=", "list", "(", ")", "for", "el", "in", "arr", ":", "res", ".", "append", "(", "func", "(", "el", ")", ")", "return", "res" ]

[ "Calls", "the", "given", "function", "on", "every", "element", "on", "the", "given", "array", "and", "returns", "the", "resulting", "elements", "." ]

[ "\"\"\"\n Calls the given function on every element on the given array and returns the resulting elements.\n \"\"\"" ]

[ { "param": "func", "type": null }, { "param": "arr", "type": "list" } ]

{ "returns": [], "raises": [], "params": [ { "identifier": "func", "type": null, "docstring": null, "docstring_tokens": [], "default": null, "is_optional": null }, { "identifier": "arr", "type": "list", "docstring": null, "docstring_tokens": [], "default": null, "is_optional": null } ], "outlier_params": [], "others": [] }

[ "MIT" ]

[ "Adds", "the", "required", "scape", "characters", "to", "the", "format", "file", "." ]

[ "def", "_scaper", "(", "input_string", ")", ":", "scaped_string", "=", "input_string", ".", "replace", "(", "'\"'", ",", "'\\\\\"'", ")", ".", "replace", "(", "\"'\"", ",", "\"\\\\'\"", ")", ".", "replace", "(", "'\\r'", ",", "'\\\\r'", ")", ".", "replace", "(", "'\\n'", ",", "'\\\\n'", ")", "return", "scaped_string" ]

[ "Adds", "the", "required", "scape", "characters", "to", "the", "format", "file", "." ]

[ "\"\"\"Adds the required scape characters to the format file.\n :param input_string: Value before scaping\n :type input_string: str\n :return: Scaped string\n \"\"\"" ]

[ { "param": "input_string", "type": null } ]

{ "returns": [ { "docstring": null, "docstring_tokens": [ "None" ], "type": null } ], "raises": [], "params": [ { "identifier": "input_string", "type": null, "docstring": "Value before scaping", "docstring_tokens": [ "Value", "before", "scaping" ], "default": null, "is_optional": null } ], "outlier_params": [], "others": [] }

[ "MIT" ]

[ "Turns", "an", "A", "containing", "Bs", "into", "a", "B", "of", "As", "where", "A", "B", "are", "container", "types" ]

[ "def", "distribute", "(", "A", ",", "B", ")", ":", "def", "distribute_rl", "(", "expr", ")", ":", "for", "i", ",", "arg", "in", "enumerate", "(", "expr", ".", "args", ")", ":", "if", "isinstance", "(", "arg", ",", "B", ")", ":", "first", ",", "b", ",", "tail", "=", "expr", ".", "args", "[", ":", "i", "]", ",", "expr", ".", "args", "[", "i", "]", ",", "expr", ".", "args", "[", "i", "+", "1", ":", "]", "return", "B", "(", "*", "[", "A", "(", "*", "(", "first", "+", "(", "arg", ",", ")", "+", "tail", ")", ")", "for", "arg", "in", "b", ".", "args", "]", ")", "return", "expr", "return", "distribute_rl" ]

[ "Turns", "an", "A", "containing", "Bs", "into", "a", "B", "of", "As", "where", "A", "B", "are", "container", "types" ]

[ "\"\"\" Turns an A containing Bs into a B of As\n\n where A, B are container types\n\n >>> from sympy.strategies import distribute\n >>> from sympy import Add, Mul, symbols\n >>> x, y = symbols('x,y')\n >>> dist = distribute(Mul, Add)\n >>> expr = Mul(2, x+y, evaluate=False)\n >>> expr\n 2*(x + y)\n >>> dist(expr)\n 2*x + 2*y\n \"\"\"" ]

[ { "param": "A", "type": null }, { "param": "B", "type": null } ]

{ "returns": [], "raises": [], "params": [ { "identifier": "A", "type": null, "docstring": null, "docstring_tokens": [], "default": null, "is_optional": null }, { "identifier": "B", "type": null, "docstring": null, "docstring_tokens": [], "default": null, "is_optional": null } ], "outlier_params": [], "others": [] }

[ "MIT" ]

[ "Creates", "a", "TCP", "socket", "wrapped", "in", "SSL", "." ]

[ "def", "make_ssocket", "(", "protocol", ",", "ciphers", "=", "ssl", ".", "_DEFAULT_CIPHERS", ")", ":", "return", "ssl", ".", "wrap_socket", "(", "socket", ".", "socket", "(", ")", ",", "ssl_version", "=", "protocol", ",", "ciphers", "=", "ciphers", ")" ]

[ "Creates", "a", "TCP", "socket", "wrapped", "in", "SSL", "." ]

[ "\"\"\"Creates a TCP socket wrapped in SSL.\"\"\"" ]

[ { "param": "protocol", "type": null }, { "param": "ciphers", "type": null } ]

{ "returns": [], "raises": [], "params": [ { "identifier": "protocol", "type": null, "docstring": null, "docstring_tokens": [], "default": null, "is_optional": null }, { "identifier": "ciphers", "type": null, "docstring": null, "docstring_tokens": [], "default": null, "is_optional": null } ], "outlier_params": [], "others": [] }

[ "MIT" ]

[ "Calculate", "the", "total", "number", "of", "tokens", "in", "a", "rule", "." ]

[ "def", "_num_tokens_of", "(", "rule", ")", ":", "total", "=", "len", "(", "rule", ".", "get", "(", "\"tokens\"", ")", ")", "for", "_", "in", "(", "\"prev_classes\"", ",", "\"prev_tokens\"", ",", "\"next_tokens\"", ",", "\"next_classes\"", ")", ":", "val", "=", "rule", ".", "get", "(", "_", ")", "if", "val", ":", "total", "+=", "len", "(", "val", ")", "return", "total" ]

[ "Calculate", "the", "total", "number", "of", "tokens", "in", "a", "rule", "." ]

[ "\"\"\"Calculate the total number of tokens in a rule.\"\"\"" ]

[ { "param": "rule", "type": null } ]

{ "returns": [], "raises": [], "params": [ { "identifier": "rule", "type": null, "docstring": null, "docstring_tokens": [], "default": null, "is_optional": null } ], "outlier_params": [], "others": [] }

[ "MIT" ]

[ "Update", "a", "character", "'", "s", "XP", "." ]

[ "def", "__update_xp", "(", "character", ":", "VChar", ",", "xp_type", ":", "str", ",", "delta", ":", "str", ")", "->", "str", ":", "setting", "=", "False", "if", "isinstance", "(", "delta", ",", "str", ")", ":", "if", "delta", "[", "0", "]", "not", "in", "[", "\"+\"", ",", "\"-\"", "]", ":", "setting", "=", "True", "if", "not", "xp_type", "in", "[", "\"total\"", ",", "\"current\"", "]", ":", "raise", "SyntaxError", "(", "f\"Unknown XP type: {xp_type}.\"", ")", "delta", "=", "int", "(", "delta", ")", "new_xp", "=", "None", "if", "setting", ":", "new_xp", "=", "delta", "else", ":", "current", "=", "getattr", "(", "character", ",", "f\"{xp_type.lower()}_xp\"", ")", "new_xp", "=", "current", "+", "delta", "current", "=", "character", ".", "current_xp", "if", "xp_type", "==", "\"current\"", ":", "character", ".", "current_xp", "=", "new_xp", "cur_delta", "=", "character", ".", "current_xp", "-", "current", "if", "setting", ":", "return", "f\"Set current/unspent XP to `{new_xp}`.\"", "return", "f\"`{cur_delta:+}` current/unspent XP.\"", "total", "=", "character", ".", "total_xp", "character", ".", "total_xp", "=", "new_xp", "tot_delta", "=", "character", ".", "total_xp", "-", "total", "cur_delta", "=", "character", ".", "current_xp", "-", "current", "if", "setting", ":", "return", "f\"Set unspent XP to `{character.current_xp}`.\\nSet lifetime XP to `{new_xp}`.\"", "return", "f\"`{cur_delta:+}` unspent XP.\\n`{tot_delta:+}` lifetime XP.\"" ]

[ "Update", "a", "character", "'", "s", "XP", "." ]

[ "\"\"\"\n Update a character's XP.\n Args:\n character (VChar): The character to update\n xp_type (str): \"total\" or \"current\"\n delta (str): The amount to add or remove\n\n Does not catch exceptions.\n \"\"\"", "# If the user doesn't supply a sign, they are setting the XP total rather", "# than modifying it", "# Should never be seen", "# When displaying the update, we want to say whether they are doing a delta vs", "# set and, if doing a delta, the *final* amound added/subtracted, after doing", "# bounds-checking." ]

[ { "param": "character", "type": "VChar" }, { "param": "xp_type", "type": "str" }, { "param": "delta", "type": "str" } ]

{ "returns": [], "raises": [], "params": [ { "identifier": "character", "type": "VChar", "docstring": "The character to update", "docstring_tokens": [ "The", "character", "to", "update" ], "default": null, "is_optional": false }, { "identifier": "xp_type", "type": "str", "docstring": "\"total\" or \"current\"", "docstring_tokens": [ "\"", "total", "\"", "or", "\"", "current", "\"" ], "default": null, "is_optional": false }, { "identifier": "delta", "type": "str", "docstring": "The amount to add or remove", "docstring_tokens": [ "The", "amount", "to", "add", "or", "remove" ], "default": null, "is_optional": false } ], "outlier_params": [], "others": [] }

[ "Apache-2.0" ]

[ "Validate", "a", "given", "typle", "of", "coordinates", "." ]

[ "def", "_validate_coord", "(", "coord", ")", ":", "assert", "(", "isinstance", "(", "coord", ",", "tuple", ")", "and", "len", "(", "coord", ")", "==", "2", "and", "isinstance", "(", "coord", "[", "0", "]", ",", "int", ")", "and", "isinstance", "(", "coord", "[", "1", "]", ",", "int", ")", ")", "return", "coord" ]

[ "Validate", "a", "given", "typle", "of", "coordinates", "." ]

[ "\"\"\"Validate a given typle of coordinates.\"\"\"" ]

[ { "param": "coord", "type": null } ]

{ "returns": [], "raises": [], "params": [ { "identifier": "coord", "type": null, "docstring": null, "docstring_tokens": [], "default": null, "is_optional": null } ], "outlier_params": [], "others": [] }

[ "MIT" ]

[ "Append", "the", "supplied", "string", "to", "file" ]

[ "def", "appendLine", "(", "line", ")", ":", "snOut", "=", "open", "(", "\"ResultsSeven.csv\"", ",", "\"a\"", ")", "snOut", ".", "write", "(", "line", ")", "snOut", ".", "close", "(", ")" ]

[ "Append", "the", "supplied", "string", "to", "file" ]

[ "\"\"\"Append the supplied string to file\"\"\"" ]

[ { "param": "line", "type": null } ]

{ "returns": [], "raises": [], "params": [ { "identifier": "line", "type": null, "docstring": null, "docstring_tokens": [], "default": null, "is_optional": null } ], "outlier_params": [], "others": [] }

[ "Apache-2.0" ]

[ "Save", "board", "into", "json", "save", "file" ]

[ "def", "save_game", "(", "board", ")", "->", "None", ":", "board", ".", "to_json", "(", ")" ]

[ "Save", "board", "into", "json", "save", "file" ]

[ "\"\"\"\n Save board into json save file\n :param board: Board object\n :return: None\n \"\"\"" ]

[ { "param": "board", "type": null } ]

{ "returns": [ { "docstring": null, "docstring_tokens": [ "None" ], "type": null } ], "raises": [], "params": [ { "identifier": "board", "type": null, "docstring": null, "docstring_tokens": [ "None" ], "default": null, "is_optional": null } ], "outlier_params": [], "others": [] }

[ "Apache-2.0" ]

[ "Correct", "common", "Prisma", "Cloud", "API", "URL", "misconfigurations" ]

[ "def", "normalize_prisma_url", "(", "url", ":", "str", ")", ":", "if", "not", "url", ":", "return", "None", "return", "url", ".", "lower", "(", ")", ".", "replace", "(", "'//app'", ",", "'//api'", ")", ".", "replace", "(", "'http:'", ",", "'https:'", ")", ".", "rstrip", "(", "'/'", ")" ]

[ "Correct", "common", "Prisma", "Cloud", "API", "URL", "misconfigurations" ]

[ "\"\"\" Correct common Prisma Cloud API URL misconfigurations \"\"\"" ]

[ { "param": "url", "type": "str" } ]

{ "returns": [], "raises": [], "params": [ { "identifier": "url", "type": "str", "docstring": null, "docstring_tokens": [], "default": null, "is_optional": null } ], "outlier_params": [], "others": [] }

[ "Apache-2.0" ]

[ "Fixture", "returning", "a", "ChangeEvents", "object", "with", "a", "withdrawn", "path" ]

[ "def", "chObject_withdrawn", "(", "ct_obj", ",", "db_dict", ")", ":", "ct_obj", ".", "prod_tree", "=", "os", ".", "getenv", "(", "'DATADIR'", ")", "+", "\"/ctree/current.plus1.tree\"", "file_dict", "=", "ct_obj", ".", "get_file_dict", "(", ")", "chObject", "=", "ct_obj", ".", "cmp_dicts", "(", "db_dict", "=", "db_dict", ",", "file_dict", "=", "file_dict", ")", "return", "chObject" ]

[ "Fixture", "returning", "a", "ChangeEvents", "object", "with", "a", "withdrawn", "path" ]

[ "\"\"\"\n Fixture returning a ChangeEvents object\n with a withdrawn path\n \"\"\"" ]

[ { "param": "ct_obj", "type": null }, { "param": "db_dict", "type": null } ]

{ "returns": [], "raises": [], "params": [ { "identifier": "ct_obj", "type": null, "docstring": null, "docstring_tokens": [], "default": null, "is_optional": null }, { "identifier": "db_dict", "type": null, "docstring": null, "docstring_tokens": [], "default": null, "is_optional": null } ], "outlier_params": [], "others": [] }

[ "MIT" ]

[ "DEFAULT", "VERSION", "`", "v1", "`", "This", "method", "will", "return", "a", "dictionary", "object", "with", "version", "number", "and", "fields", "name", ".", "Fields", "are", "similar", "like", "serializer", "fields", ".", "Or", "you", "can", "say", "exactly", "as", "same", "as", "serializer", "fields", "." ]

[ "def", "api_version_fields", "(", "cls", ",", "**", "kwargs", ")", ":", "versions", "=", "{", "'v1'", ":", "[", "'id'", ",", "'author'", ",", "'title'", ",", "'description'", "]", ",", "'v2'", ":", "{", "'fields'", ":", "[", "'pk'", ",", "'author'", ",", "'title'", ",", "'description'", ",", "'meta'", ",", "'photo'", "]", ",", "'read_only_fields'", ":", "[", "'pk'", ",", "'meta'", ",", "'photo'", "]", ",", "'optional_fields'", ":", "[", "'description'", ",", "'author'", "]", "}", "}", "return", "versions" ]

[ "DEFAULT", "VERSION", "`", "v1", "`", "This", "method", "will", "return", "a", "dictionary", "object", "with", "version", "number", "and", "fields", "name", "." ]

[ "\"\"\"\n *** DEFAULT VERSION `v1` ***\n\n This method will return a dictionary object with version number and fields name. Fields are similar like\n serializer fields. Or you can say exactly as same as serializer fields.\n :param kwargs: Currently nothing to receive on kwargs\n :return: a dictionary object with version number\n \"\"\"" ]

[ { "param": "cls", "type": null } ]

{ "returns": [ { "docstring": "a dictionary object with version number", "docstring_tokens": [ "a", "dictionary", "object", "with", "version", "number" ], "type": null } ], "raises": [], "params": [ { "identifier": "cls", "type": null, "docstring": null, "docstring_tokens": [], "default": null, "is_optional": null } ], "outlier_params": [ { "identifier": "kwargs", "type": null, "docstring": "Currently nothing to receive on kwargs", "docstring_tokens": [ "Currently", "nothing", "to", "receive", "on", "kwargs" ], "default": null, "is_optional": null } ], "others": [] }

[ "Apache-2.0" ]

[ "Limit", "the", "max", "number", "of", "samples", "that", "reader", "could", "return", "." ]

[ "def", "firstn", "(", "reader", ",", "n", ")", ":", "def", "firstn_reader", "(", ")", ":", "for", "i", ",", "item", "in", "enumerate", "(", "reader", "(", ")", ")", ":", "if", "i", "==", "n", ":", "break", "yield", "item", "return", "firstn_reader" ]

[ "Limit", "the", "max", "number", "of", "samples", "that", "reader", "could", "return", "." ]

[ "\"\"\"\n Limit the max number of samples that reader could return.\n\n :param reader: the data reader to read from.\n :type reader: callable\n :param n: the max number of samples that return.\n :type n: int\n :return: the decorated reader.\n :rtype: callable\n \"\"\"", "# TODO(yuyang18): Check if just drop the reader, could clean the opened", "# resource or not?" ]

[ { "param": "reader", "type": null }, { "param": "n", "type": null } ]

{ "returns": [ { "docstring": "the decorated reader.", "docstring_tokens": [ "the", "decorated", "reader", "." ], "type": "callable" } ], "raises": [], "params": [ { "identifier": "reader", "type": null, "docstring": "the data reader to read from.", "docstring_tokens": [ "the", "data", "reader", "to", "read", "from", "." ], "default": null, "is_optional": null }, { "identifier": "n", "type": null, "docstring": "the max number of samples that return.", "docstring_tokens": [ "the", "max", "number", "of", "samples", "that", "return", "." ], "default": null, "is_optional": null } ], "outlier_params": [], "others": [] }

[ "BSD-2-Clause-FreeBSD" ]

[ "Generates", "a", "public", "key", "object", "from", "a", "PrivateKey", "object", "." ]

[ "def", "from_private_key", "(", "private_key", ")", ":", "return", "private_key", ".", "public_key" ]

[ "Generates", "a", "public", "key", "object", "from", "a", "PrivateKey", "object", "." ]

[ "\"\"\" Generates a public key object from a PrivateKey object.\n\n Args:\n private_key (PrivateKey): The private key object from\n which to derive this object.\n\n Returns:\n PublicKey: A PublicKey object.\n \"\"\"" ]

[ { "param": "private_key", "type": null } ]

{ "returns": [ { "docstring": "A PublicKey object.", "docstring_tokens": [ "A", "PublicKey", "object", "." ], "type": "PublicKey" } ], "raises": [], "params": [ { "identifier": "private_key", "type": null, "docstring": "The private key object from\nwhich to derive this object.", "docstring_tokens": [ "The", "private", "key", "object", "from", "which", "to", "derive", "this", "object", "." ], "default": null, "is_optional": false } ], "outlier_params": [], "others": [] }

[ "MIT" ]

[ "Limit", "wildcards", "to", "the", "given", "values", ".", "Arguments", ":", "wildcards", "--", "the", "wildcards", "as", "keyword", "arguments", "with", "their", "values", "as", "lists" ]

[ "def", "limit", "(", "pattern", ",", "**", "wildcards", ")", ":", "return", "pattern", ".", "format", "(", "**", "{", "wildcard", ":", "\"{{{},{}}}\"", ".", "format", "(", "wildcard", ",", "\"|\"", ".", "join", "(", "values", ")", ")", "for", "wildcard", ",", "values", "in", "wildcards", ".", "items", "(", ")", "}", ")" ]

[ "Limit", "wildcards", "to", "the", "given", "values", "." ]

[ "\"\"\"\n Limit wildcards to the given values.\n\n Arguments:\n **wildcards -- the wildcards as keyword arguments\n with their values as lists\n \"\"\"" ]

[ { "param": "pattern", "type": null } ]

{ "returns": [], "raises": [], "params": [ { "identifier": "pattern", "type": null, "docstring": null, "docstring_tokens": [], "default": null, "is_optional": null } ], "outlier_params": [], "others": [] }

[ "Apache-2.0" ]

[ "Writes", "HTTP", "request", "result", "to", "stdout", "." ]

[ "def", "print_result_for_plain_cgi_script", "(", "contenttype", ":", "str", ",", "headers", ":", "TYPE_WSGI_RESPONSE_HEADERS", ",", "content", ":", "bytes", ",", "status", ":", "str", "=", "'200 OK'", ")", "->", "None", ":", "headers", "=", "[", "(", "\"Status\"", ",", "status", ")", ",", "(", "\"Content-Type\"", ",", "contenttype", ")", ",", "(", "\"Content-Length\"", ",", "str", "(", "len", "(", "content", ")", ")", ")", ",", "]", "+", "headers", "sys", ".", "stdout", ".", "write", "(", "\"\\n\"", ".", "join", "(", "[", "h", "[", "0", "]", "+", "\": \"", "+", "h", "[", "1", "]", "for", "h", "in", "headers", "]", ")", "+", "\"\\n\\n\"", ")", "sys", ".", "stdout", ".", "buffer", ".", "write", "(", "content", ")" ]

[ "Writes", "HTTP", "request", "result", "to", "stdout", "." ]

[ "\"\"\"\n Writes HTTP request result to stdout.\n \"\"\"" ]

[ { "param": "contenttype", "type": "str" }, { "param": "headers", "type": "TYPE_WSGI_RESPONSE_HEADERS" }, { "param": "content", "type": "bytes" }, { "param": "status", "type": "str" } ]

{ "returns": [], "raises": [], "params": [ { "identifier": "contenttype", "type": "str", "docstring": null, "docstring_tokens": [], "default": null, "is_optional": null }, { "identifier": "headers", "type": "TYPE_WSGI_RESPONSE_HEADERS", "docstring": null, "docstring_tokens": [], "default": null, "is_optional": null }, { "identifier": "content", "type": "bytes", "docstring": null, "docstring_tokens": [], "default": null, "is_optional": null }, { "identifier": "status", "type": "str", "docstring": null, "docstring_tokens": [], "default": null, "is_optional": null } ], "outlier_params": [], "others": [] }

[ "MIT" ]

[ "Computes", "the", "statistics", "of", "3", "rules", ":", "1", ".", "the", "new", "subgroup", "rule", "2", ".", "the", "old", "\"", "default", "\"", "rule", "that", "covered", "the", "subgroup", "(", "only", "the", "cover", "of", "the", "subgroup", "not", "the", "rest", ")", "3", ".", "the", "new", "default", "rule", "that", "covers", "the", "region", "not", "covered", "by", "any", "subgroup", "." ]

[ "def", "compute_statistics_newrules", "(", "rulelist", ",", "data", ",", "bitarray_subgroup", ")", ":", "rulelist", ".", "tmp_subgroup_statistic", "=", "rulelist", ".", "tmp_subgroup_statistic", ".", "replace_stats", "(", "data", ",", "bitarray_subgroup", ")", "bitarray_new_defaultrule", "=", "rulelist", ".", "bitset_uncovered", "&", "~", "bitarray_subgroup", "rulelist", ".", "tmp_default_statistic", "=", "rulelist", ".", "tmp_default_statistic", ".", "replace_stats", "(", "data", ",", "bitarray_new_defaultrule", ")", "return", "rulelist", ".", "tmp_subgroup_statistic", ",", "rulelist", ".", "tmp_default_statistic" ]

[ "Computes", "the", "statistics", "of", "3", "rules", ":", "1", ".", "the", "new", "subgroup", "rule", "2", ".", "the", "old", "\"", "default", "\"", "rule", "that", "covered", "the", "subgroup", "(", "only", "the", "cover", "of", "the", "subgroup", "not", "the", "rest", ")", "3", ".", "the", "new", "default", "rule", "that", "covers", "the", "region", "not", "covered", "by", "any", "subgroup", "." ]

[ "\"\"\" Computes the statistics of 3 rules:\n 1. the new subgroup rule\n 2. the old \"default\" rule that covered the subgroup (only the cover of the subgroup not the rest)\n 3. the new default rule that covers the region not covered by any subgroup.\n\n \"\"\"" ]

[ { "param": "rulelist", "type": null }, { "param": "data", "type": null }, { "param": "bitarray_subgroup", "type": null } ]

{ "returns": [], "raises": [], "params": [ { "identifier": "rulelist", "type": null, "docstring": null, "docstring_tokens": [], "default": null, "is_optional": null }, { "identifier": "data", "type": null, "docstring": null, "docstring_tokens": [], "default": null, "is_optional": null }, { "identifier": "bitarray_subgroup", "type": null, "docstring": null, "docstring_tokens": [], "default": null, "is_optional": null } ], "outlier_params": [], "others": [] }

[ "MIT" ]

[ "Perform", "results", "reading", "from", "the", "related", "filepath" ]

[ "def", "parse_last_epoch_results", "(", "filepath", ")", ":", "iters", "=", "None", "with", "open", "(", "filepath", ")", "as", "f", ":", "for", "line", "in", "f", ".", "readlines", "(", ")", ":", "if", "u'last per iterations'", "in", "line", ":", "arr", "=", "line", ".", "split", "(", "':'", ")", "[", "1", "]", ".", "strip", "(", ")", "vals", "=", "arr", "[", "1", ":", "-", "1", "]", "iters", "=", "[", "float", "(", "v", ")", "for", "v", "in", "vals", ".", "split", "(", "','", ")", "]", "return", "iters" ]

[ "Perform", "results", "reading", "from", "the", "related", "filepath" ]

[ "\"\"\" Perform results reading from the related filepath\n \"\"\"", "# Example to parse:", "# F1-last per iterations: [0.32, 0.229, 0.311]" ]

[ { "param": "filepath", "type": null } ]

{ "returns": [], "raises": [], "params": [ { "identifier": "filepath", "type": null, "docstring": null, "docstring_tokens": [], "default": null, "is_optional": null } ], "outlier_params": [], "others": [] }

[ "MIT" ]

[ "Returns", "the", "base", "10", "order", "of", "magnitude", "of", "a", "number" ]

[ "def", "order", "(", "x", ",", "count", "=", "0", ")", ":", "if", "x", "/", "10", ">=", "1", ":", "count", "+=", "order", "(", "x", "/", "10", ",", "count", ")", "+", "1", "return", "count" ]

[ "Returns", "the", "base", "10", "order", "of", "magnitude", "of", "a", "number" ]

[ "\"\"\"Returns the base 10 order of magnitude of a number\"\"\"" ]

[ { "param": "x", "type": null }, { "param": "count", "type": null } ]

{ "returns": [], "raises": [], "params": [ { "identifier": "x", "type": null, "docstring": null, "docstring_tokens": [], "default": null, "is_optional": null }, { "identifier": "count", "type": null, "docstring": null, "docstring_tokens": [], "default": null, "is_optional": null } ], "outlier_params": [], "others": [] }

[ "BSD-3-Clause" ]

[ "axis", "dictionary", "for", "landscape", "pages", "." ]

[ "def", "axd_landscape", "(", "axs", ")", ":", "return", "{", "(", "'Low'", ",", "1", ")", ":", "axs", "[", "0", ",", "0", "]", ",", "(", "'Low'", ",", "2", ")", ":", "axs", "[", "0", ",", "1", "]", ",", "(", "'Low'", ",", "3", ")", ":", "axs", "[", "0", ",", "2", "]", ",", "(", "'Low'", ",", "4", ")", ":", "axs", "[", "0", ",", "3", "]", ",", "(", "'High'", ",", "1", ")", ":", "axs", "[", "1", ",", "0", "]", ",", "(", "'High'", ",", "2", ")", ":", "axs", "[", "1", ",", "1", "]", ",", "(", "'High'", ",", "3", ")", ":", "axs", "[", "1", ",", "2", "]", ",", "(", "'High'", ",", "4", ")", ":", "axs", "[", "1", ",", "3", "]", "}" ]

[ "axis", "dictionary", "for", "landscape", "pages", "." ]

[ "\"\"\"\n axis dictionary for landscape pages.\n \"\"\"" ]

[ { "param": "axs", "type": null } ]

{ "returns": [], "raises": [], "params": [ { "identifier": "axs", "type": null, "docstring": null, "docstring_tokens": [], "default": null, "is_optional": null } ], "outlier_params": [], "others": [] }

[ "Apache-2.0" ]

[ "Convert", "a", "string", "to", "Hex", "format" ]

[ "def", "string_utf8_to_hex", "(", "name", ")", ":", "return", "bytes", "(", "name", ",", "encoding", "=", "'utf-8'", ")", ".", "hex", "(", ")" ]

[ "Convert", "a", "string", "to", "Hex", "format" ]

[ "\"\"\"Convert a string to Hex format\n\n Args:\n name (str): string\n\n \"\"\"" ]

[ { "param": "name", "type": null } ]

{ "returns": [], "raises": [], "params": [ { "identifier": "name", "type": null, "docstring": null, "docstring_tokens": [ "None" ], "default": null, "is_optional": false } ], "outlier_params": [], "others": [] }

[ "MIT" ]

[ "remove", "all", "gapped", "columns", "in", "mali", "." ]

[ "def", "removeGappedColumns", "(", "mali", ",", "gap_char", "=", "\"-\"", ")", ":", "if", "len", "(", "mali", ")", "==", "0", ":", "return", "mali", "keys", "=", "mali", ".", "keys", "(", ")", "lmali", "=", "len", "(", "mali", "[", "keys", "[", "0", "]", "]", ")", "wmali", "=", "len", "(", "keys", ")", "gaps_per_column", "=", "[", "0", "]", "*", "lmali", "for", "m", "in", "mali", ".", "values", "(", ")", ":", "for", "x", "in", "range", "(", "lmali", ")", ":", "if", "m", "[", "x", "]", "==", "gap_char", ":", "gaps_per_column", "[", "x", "]", "+=", "1", "new_mali", "=", "{", "}", "for", "k", "in", "keys", ":", "s", "=", "[", "]", "m", "=", "mali", "[", "k", "]", "for", "x", "in", "range", "(", "lmali", ")", ":", "if", "gaps_per_column", "[", "x", "]", "<", "wmali", ":", "s", "+=", "m", "[", "x", "]", "new_mali", "[", "k", "]", "=", "string", ".", "join", "(", "s", ",", "\"\"", ")", "return", "new_mali" ]

[ "remove", "all", "gapped", "columns", "in", "mali", "." ]

[ "\"\"\"remove all gapped columns in mali.\"\"\"" ]

[ { "param": "mali", "type": null }, { "param": "gap_char", "type": null } ]

{ "returns": [], "raises": [], "params": [ { "identifier": "mali", "type": null, "docstring": null, "docstring_tokens": [], "default": null, "is_optional": null }, { "identifier": "gap_char", "type": null, "docstring": null, "docstring_tokens": [], "default": null, "is_optional": null } ], "outlier_params": [], "others": [] }

[ "Apache-2.0" ]

[ "Trim", "and", "pad", "with", "zeroes", "search", "query", "mhr", "number", "query", "." ]

[ "def", "format_mhr_number", "(", "request_json", ")", ":", "mhr_num", ":", "str", "=", "request_json", "[", "'criteria'", "]", "[", "'value'", "]", "mhr_num", "=", "mhr_num", ".", "strip", "(", ")", ".", "rjust", "(", "6", ",", "'0'", ")", "request_json", "[", "'criteria'", "]", "[", "'value'", "]", "=", "mhr_num" ]

[ "Trim", "and", "pad", "with", "zeroes", "search", "query", "mhr", "number", "query", "." ]

[ "\"\"\"Trim and pad with zeroes search query mhr number query.\"\"\"" ]

[ { "param": "request_json", "type": null } ]

{ "returns": [], "raises": [], "params": [ { "identifier": "request_json", "type": null, "docstring": null, "docstring_tokens": [], "default": null, "is_optional": null } ], "outlier_params": [], "others": [] }

[ "CC0-1.0" ]

[ "Implementation", "of", "the", "selection", "sort", "algorithm", "using", "Python", "inside", "parameter", "we", "can", "pass", "some", "items", "which", "are", "heterogeneous", "comparable" ]

[ "def", "selection_sort", "(", "items", ")", ":", "length", "=", "len", "(", "items", ")", "for", "i", "in", "range", "(", "length", ")", ":", "least", "=", "i", "for", "j", "in", "range", "(", "i", "+", "1", ",", "length", ")", ":", "if", "items", "[", "j", "]", "<", "items", "[", "least", "]", ":", "least", "=", "j", "items", "[", "least", "]", ",", "items", "[", "i", "]", "=", "(", "items", "[", "i", "]", ",", "items", "[", "least", "]", ")", "return", "items" ]

[ "Implementation", "of", "the", "selection", "sort", "algorithm", "using", "Python", "inside", "parameter", "we", "can", "pass", "some", "items", "which", "are", "heterogeneous", "comparable" ]

[ "\"\"\"Implementation of the selection sort algorithm using Python\n inside parameter we can pass some items which are heterogeneous\n comparable\n \"\"\"" ]

[ { "param": "items", "type": null } ]

{ "returns": [], "raises": [], "params": [ { "identifier": "items", "type": null, "docstring": null, "docstring_tokens": [], "default": null, "is_optional": null } ], "outlier_params": [], "others": [] }

[ "MIT" ]

[ "Firm", "'", "s", "book", "value", "as", "of", "latest", "quarterly", "earnings", "report", "preceding", "date", "Relies", "on", "naming", "of", "pdatabase", "(", "compustat", ")", "and", "chronological", "data", "for", "each", "firm", "Returns", "-", "1", "if", "no", "data", "available", "Returns", "FLOAT" ]

[ "def", "bookValue", "(", "firm", ",", "date", ",", "pdatabase", ",", "printWarnings", "=", "True", ",", "bookUnit", "=", "1000000", ")", ":", "bookQuery", "=", "pdatabase", ".", "data", ".", "query", "(", "'(tic == \"'", "+", "firm", "+", "'\") & (datadate < '", "+", "date", "+", "')'", ")", "if", "bookQuery", ".", "empty", ":", "if", "printWarnings", ":", "print", "(", "\"NO BOOK DATA: \"", "+", "firm", "+", "\", \"", "+", "date", ")", "return", "-", "1", "bookSeries", "=", "bookQuery", "[", "\"ceqq\"", "]", "return", "float", "(", "bookSeries", ".", "iat", "[", "bookSeries", ".", "size", "-", "1", "]", "*", "bookUnit", ")" ]

[ "Firm", "'", "s", "book", "value", "as", "of", "latest", "quarterly", "earnings", "report", "preceding", "date", "Relies", "on", "naming", "of", "pdatabase", "(", "compustat", ")", "and", "chronological", "data", "for", "each", "firm", "Returns", "-", "1", "if", "no", "data", "available", "Returns", "FLOAT" ]

[ "\"\"\"\n Firm's book value as of latest quarterly earnings report preceding date\n Relies on naming of pdatabase (compustat) and chronological data for each firm\n Returns -1 if no data available\n Returns FLOAT\n \"\"\"", "# print(bookQuery)" ]

[ { "param": "firm", "type": null }, { "param": "date", "type": null }, { "param": "pdatabase", "type": null }, { "param": "printWarnings", "type": null }, { "param": "bookUnit", "type": null } ]

{ "returns": [], "raises": [], "params": [ { "identifier": "firm", "type": null, "docstring": null, "docstring_tokens": [], "default": null, "is_optional": null }, { "identifier": "date", "type": null, "docstring": null, "docstring_tokens": [], "default": null, "is_optional": null }, { "identifier": "pdatabase", "type": null, "docstring": null, "docstring_tokens": [], "default": null, "is_optional": null }, { "identifier": "printWarnings", "type": null, "docstring": null, "docstring_tokens": [], "default": null, "is_optional": null }, { "identifier": "bookUnit", "type": null, "docstring": null, "docstring_tokens": [], "default": null, "is_optional": null } ], "outlier_params": [], "others": [] }

[ "Apache-2.0" ]

[ "Before", "hook", "for", "capturing", "responder", "arguments", ".", "Adds", "the", "following", "attributes", "to", "the", "hooked", "responder", "'", "s", "resource", "class", "." ]

[ "def", "capture_responder_args", "(", "req", ",", "resp", ",", "resource", ",", "params", ")", ":", "resource", ".", "captured_req", "=", "req", "resource", ".", "captured_resp", "=", "resp", "resource", ".", "captured_kwargs", "=", "params" ]

[ "Before", "hook", "for", "capturing", "responder", "arguments", "." ]

[ "\"\"\"Before hook for capturing responder arguments.\n\n Adds the following attributes to the hooked responder's resource\n class:\n\n * captured_req\n * captured_resp\n * captured_kwargs\n \"\"\"" ]

[ { "param": "req", "type": null }, { "param": "resp", "type": null }, { "param": "resource", "type": null }, { "param": "params", "type": null } ]

{ "returns": [], "raises": [], "params": [ { "identifier": "req", "type": null, "docstring": null, "docstring_tokens": [], "default": null, "is_optional": null }, { "identifier": "resp", "type": null, "docstring": null, "docstring_tokens": [], "default": null, "is_optional": null }, { "identifier": "resource", "type": null, "docstring": null, "docstring_tokens": [], "default": null, "is_optional": null }, { "identifier": "params", "type": null, "docstring": null, "docstring_tokens": [], "default": null, "is_optional": null } ], "outlier_params": [], "others": [] }

[ "MIT" ]

[ "To", "be", "used", "in", "conjunction", "with", "the", "object_list", "generic", "view", ".", "Adds", "pagination", "context", "variables", "for", "use", "in", "displaying", "first", "adjacent", "and", "last", "page", "links", "in", "addition", "to", "those", "created", "by", "the", "object_list", "generic", "view", ".", "Required", "context", "variables", ":", "paged", ":", "The", "Paginator", ".", "page", "()", "instance", "." ]

[ "def", "paginator", "(", "context", ",", "adjacent_pages", "=", "2", ")", ":", "paged", "=", "context", "[", "'paged'", "]", "paginator", "=", "paged", ".", "paginator", "startPage", "=", "max", "(", "paged", ".", "number", "-", "adjacent_pages", ",", "1", ")", "if", "startPage", "<=", "3", ":", "startPage", "=", "1", "endPage", "=", "paged", ".", "number", "+", "adjacent_pages", "+", "1", "if", "endPage", ">=", "paginator", ".", "num_pages", "-", "1", ":", "endPage", "=", "paginator", ".", "num_pages", "+", "1", "page_numbers", "=", "[", "n", "for", "n", "in", "range", "(", "startPage", ",", "endPage", ")", "if", "n", ">", "0", "and", "n", "<=", "paginator", ".", "num_pages", "]", "return", "{", "'paged'", ":", "paged", ",", "'paginator'", ":", "paginator", ",", "'page'", ":", "paged", ".", "number", ",", "'pages'", ":", "paginator", ".", "num_pages", ",", "'page_numbers'", ":", "page_numbers", ",", "'next'", ":", "paged", ".", "next_page_number", "(", ")", ",", "'previous'", ":", "paged", ".", "previous_page_number", "(", ")", ",", "'has_next'", ":", "paged", ".", "has_next", "(", ")", ",", "'has_previous'", ":", "paged", ".", "has_previous", "(", ")", ",", "'show_first'", ":", "1", "not", "in", "page_numbers", ",", "'show_last'", ":", "paginator", ".", "num_pages", "not", "in", "page_numbers", ",", "'last'", ":", "paginator", ".", "num_pages", ",", "}" ]

[ "To", "be", "used", "in", "conjunction", "with", "the", "object_list", "generic", "view", "." ]

[ "\"\"\"\r\n To be used in conjunction with the object_list generic view.\r\n\r\n Adds pagination context variables for use in displaying first, adjacent and\r\n last page links in addition to those created by the object_list generic\r\n view.\r\n\r\n Required context variables: paged: The Paginator.page() instance.\r\n\r\n \"\"\"", "# the paginator.page(page) instance\r" ]

[ { "param": "context", "type": null }, { "param": "adjacent_pages", "type": null } ]

{ "returns": [], "raises": [], "params": [ { "identifier": "context", "type": null, "docstring": null, "docstring_tokens": [], "default": null, "is_optional": null }, { "identifier": "adjacent_pages", "type": null, "docstring": null, "docstring_tokens": [], "default": null, "is_optional": null } ], "outlier_params": [], "others": [] }

[ "BSD-3-Clause" ]

[ "Format", "an", "AWS", "instance", "'", "s", "metadata", "for", "reporting", "." ]

[ "def", "format_aws_instance", "(", "cls", ",", "aws_instance", ")", ":", "instance_id", "=", "\"Instance ID: {instance}\"", ".", "format", "(", "instance", "=", "aws_instance", "[", "0", "]", ")", "aws_account", "=", "\"AWS Account: {account}\"", ".", "format", "(", "account", "=", "aws_instance", "[", "1", "]", "[", "\"aws_account\"", "]", ")", "aws_region", "=", "\"AWS Region: {region}\"", ".", "format", "(", "region", "=", "aws_instance", "[", "1", "]", "[", "\"aws_region\"", "]", ")", "key_name", "=", "\"Key Name: {key_}\"", ".", "format", "(", "key_", "=", "aws_instance", "[", "1", "]", "[", "\"key_name\"", "]", ")", "launch", "=", "\"Launched at: {launch}\"", ".", "format", "(", "launch", "=", "aws_instance", "[", "1", "]", "[", "\"launch_time\"", "]", ")", "vpc_id", "=", "\"VPC ID: {vpc}\"", ".", "format", "(", "vpc", "=", "aws_instance", "[", "1", "]", "[", "\"vpc_id\"", "]", ")", "ordered_fields", "=", "[", "aws_account", ",", "aws_region", ",", "key_name", ",", "vpc_id", ",", "instance_id", ",", "launch", "]", "return", "\"\\n\"", ".", "join", "(", "ordered_fields", ")" ]

[ "Format", "an", "AWS", "instance", "'", "s", "metadata", "for", "reporting", "." ]

[ "\"\"\"Format an AWS instance's metadata for reporting.\n\n Args:\n aws_instance(tuple): Formatted like this:\n (\"i-231423452\", {\"aws_account\": \"12345\",\n \"aws_region\": \"us-east-1\",\n \"key_name\": \"my_ssh_key\",\n \"launch_time\": \"1999-12-31T23:59.9\"}}\n\n \"\"\"", "# NOQA", "# NOQA", "# NOQA", "# NOQA" ]

[ { "param": "cls", "type": null }, { "param": "aws_instance", "type": null } ]

{ "returns": [], "raises": [], "params": [ { "identifier": "cls", "type": null, "docstring": null, "docstring_tokens": [], "default": null, "is_optional": null }, { "identifier": "aws_instance", "type": null, "docstring": null, "docstring_tokens": [ "None" ], "default": null, "is_optional": false } ], "outlier_params": [], "others": [] }

[ "MIT" ]

[ "Run", "the", "given", "commands", "as", "a", "subprocess", "wait", "for", "it", "to", "finish", ".", "If", "fail_abort", "is", "set", "then", "a", "non", "-", "zero", "return", "code", "will", "trigger", "an", "exception", ".", "Return", "(", "return_code", "stdout", "stderr", ")", "." ]

[ "def", "run", "(", "commands", ",", "input_string", "=", "\"\"", ",", "fail_abort", "=", "True", ")", ":", "process", "=", "subprocess", ".", "Popen", "(", "commands", ",", "stdin", "=", "subprocess", ".", "PIPE", ",", "stdout", "=", "subprocess", ".", "PIPE", ",", "stderr", "=", "subprocess", ".", "PIPE", ")", "stdout", ",", "stderr", "=", "process", ".", "communicate", "(", "input", "=", "input_string", ")", "return_code", "=", "process", ".", "returncode", "if", "return_code", "!=", "0", "and", "fail_abort", ":", "raise", "Exception", "(", "\"Command returned non-zero: %s\\n\"", "\"Return code: %s\\n\"", "\"Stdout: %s\\n\"", "\"Stderr: %s\\n\"", "%", "(", "commands", ",", "return_code", ",", "stdout", ",", "stderr", ")", ")", "return", "(", "return_code", ",", "stdout", ",", "stderr", ")" ]

[ "Run", "the", "given", "commands", "as", "a", "subprocess", "wait", "for", "it", "to", "finish", "." ]

[ "\"\"\"\n Run the given commands as a subprocess, wait for it to finish.\n If fail_abort is set, then a non-zero return code will trigger\n an exception.\n Return (return_code, stdout, stderr).\n \"\"\"" ]

[ { "param": "commands", "type": null }, { "param": "input_string", "type": null }, { "param": "fail_abort", "type": null } ]

{ "returns": [], "raises": [], "params": [ { "identifier": "commands", "type": null, "docstring": null, "docstring_tokens": [], "default": null, "is_optional": null }, { "identifier": "input_string", "type": null, "docstring": null, "docstring_tokens": [], "default": null, "is_optional": null }, { "identifier": "fail_abort", "type": null, "docstring": null, "docstring_tokens": [], "default": null, "is_optional": null } ], "outlier_params": [], "others": [] }

[ "MIT" ]

[ "Removes", "elements", "with", "duplicate", "keys", "maintaining", "original", "order", "." ]

[ "def", "nub_by", "(", "xs", ",", "key", ")", ":", "seen", "=", "set", "(", ")", "def", "check_and_add", "(", "x", ")", ":", "k", "=", "key", "(", "x", ")", "if", "k", "not", "in", "seen", ":", "seen", ".", "add", "(", "k", ")", "return", "True", "return", "False", "return", "(", "x", "for", "x", "in", "xs", "if", "check_and_add", "(", "x", ")", ")" ]

[ "Removes", "elements", "with", "duplicate", "keys", "maintaining", "original", "order", "." ]

[ "\"\"\" Removes elements with duplicate keys, maintaining original order. \"\"\"" ]

[ { "param": "xs", "type": null }, { "param": "key", "type": null } ]

{ "returns": [], "raises": [], "params": [ { "identifier": "xs", "type": null, "docstring": null, "docstring_tokens": [], "default": null, "is_optional": null }, { "identifier": "key", "type": null, "docstring": null, "docstring_tokens": [], "default": null, "is_optional": null } ], "outlier_params": [], "others": [] }

[ "Apache-2.0" ]

[ "Remove", "all", "Nones", "from", "a", "tree", ".", "May", "return", "None", "if", "tree", "is", "None", "however", "." ]

[ "def", "pruneTree", "(", "cls", ",", "tree", ")", ":", "if", "not", "isinstance", "(", "tree", ",", "dict", ")", ":", "return", "tree", "else", ":", "returnDict", "=", "{", "}", "for", "key", ",", "value", "in", "tree", ".", "items", "(", ")", ":", "value_pruned", "=", "cls", ".", "pruneTree", "(", "value", ")", "if", "value_pruned", "is", "not", "None", ":", "returnDict", "[", "key", "]", "=", "value_pruned", "return", "returnDict", "or", "None" ]

[ "Remove", "all", "Nones", "from", "a", "tree", "." ]

[ "\"\"\"Remove all Nones from a tree. May return None if tree is None however.\"\"\"" ]

[ { "param": "cls", "type": null }, { "param": "tree", "type": null } ]

{ "returns": [], "raises": [], "params": [ { "identifier": "cls", "type": null, "docstring": null, "docstring_tokens": [], "default": null, "is_optional": null }, { "identifier": "tree", "type": null, "docstring": null, "docstring_tokens": [], "default": null, "is_optional": null } ], "outlier_params": [], "others": [] }

[ "Apache-2.0" ]

[ "Converts", "a", "list", "of", "separated", "RGB", "values", "into", "a", "3", "tuple", "groups", "of", "(", "R", "G", "B", ")" ]

[ "def", "rgb_unflatten", "(", "rgbCols", ")", ":", "return", "[", "tuple", "(", "rgbCols", "[", "i", ":", "i", "+", "3", "]", ")", "for", "i", "in", "range", "(", "0", ",", "len", "(", "rgbCols", ")", ",", "3", ")", "]" ]

[ "Converts", "a", "list", "of", "separated", "RGB", "values", "into", "a", "3", "tuple", "groups", "of", "(", "R", "G", "B", ")" ]

[ "'''Converts a list of separated RGB values into a 3 tuple groups of (R,G,B)\n \n Parameters:\n rgbCols [list][tuple] : A list of separate R,G,B values all being ints.\n \n On Exit:\n Combines and groups every 3 values into it's own tuple and returns a \n complete list of grouped RGB values.\n \n '''" ]

[ { "param": "rgbCols", "type": null } ]

{ "returns": [], "raises": [], "params": [ { "identifier": "rgbCols", "type": null, "docstring": null, "docstring_tokens": [], "default": null, "is_optional": null } ], "outlier_params": [ { "identifier": "rgbCols [list][tuple] ", "type": null, "docstring": "A list of separate R,G,B values all being ints.", "docstring_tokens": [ "A", "list", "of", "separate", "R", "G", "B", "values", "all", "being", "ints", "." ], "default": null, "is_optional": null } ], "others": [] }

[ "MIT" ]

[ "Attach", "a", "text", "label", "above", "each", "bar", "in", "*", "rects", "*", "displaying", "its", "height", ".", "xpos", "*", "indicates", "which", "side", "to", "place", "the", "text", "w", ".", "r", ".", "t", ".", "the", "center", "of", "the", "bar", "." ]

[ "def", "autolabel", "(", "rects", ",", "ax", ",", "xpos", "=", "'center'", ")", ":", "xpos", "=", "xpos", ".", "lower", "(", ")", "ha", "=", "{", "'center'", ":", "'center'", ",", "'right'", ":", "'left'", ",", "'left'", ":", "'right'", "}", "offset", "=", "{", "'center'", ":", "0.5", ",", "'right'", ":", "0.57", ",", "'left'", ":", "0.43", "}", "for", "rect", "in", "rects", ":", "height", "=", "rect", ".", "get_height", "(", ")", "ax", ".", "text", "(", "rect", ".", "get_x", "(", ")", "+", "rect", ".", "get_width", "(", ")", "*", "offset", "[", "xpos", "]", ",", "1.01", "*", "height", ",", "'{}'", ".", "format", "(", "height", ")", ",", "ha", "=", "ha", "[", "xpos", "]", ",", "va", "=", "'bottom'", ")" ]

[ "Attach", "a", "text", "label", "above", "each", "bar", "in", "*", "rects", "*", "displaying", "its", "height", "." ]

[ "\"\"\"\n Attach a text label above each bar in *rects*, displaying its height.\n\n *xpos* indicates which side to place the text w.r.t. the center of\n the bar. It can be one of the following {'center', 'right', 'left'}.\n \"\"\"", "# normalize the case of the parameter", "# x_txt = x + w*off" ]

[ { "param": "rects", "type": null }, { "param": "ax", "type": null }, { "param": "xpos", "type": null } ]

{ "returns": [], "raises": [], "params": [ { "identifier": "rects", "type": null, "docstring": null, "docstring_tokens": [], "default": null, "is_optional": null }, { "identifier": "ax", "type": null, "docstring": null, "docstring_tokens": [], "default": null, "is_optional": null }, { "identifier": "xpos", "type": null, "docstring": null, "docstring_tokens": [], "default": null, "is_optional": null } ], "outlier_params": [], "others": [] }

[ "MIT" ]

[ "This", "function", "is", "called", "to", "check", "if", "a", "device", "id", "is", "valid", "." ]

[ "def", "check_device", "(", "device", ")", ":", "uuid", "=", "device", ".", "get", "(", "'Device-Id'", ")", "if", "not", "uuid", ":", "return", "False", "return", "True" ]

[ "This", "function", "is", "called", "to", "check", "if", "a", "device", "id", "is", "valid", "." ]

[ "\"\"\"\n This function is called to check if a device id is valid.\n\n \"\"\"" ]

[ { "param": "device", "type": null } ]

{ "returns": [], "raises": [], "params": [ { "identifier": "device", "type": null, "docstring": null, "docstring_tokens": [], "default": null, "is_optional": null } ], "outlier_params": [], "others": [] }

[ "MIT" ]

[ "Grant", "permission", "to", "execute", "a", "file", "." ]

[ "def", "make_executable", "(", "file_path", ")", ":", "mode", "=", "os", ".", "stat", "(", "file_path", ")", ".", "st_mode", "mode", "|=", "(", "mode", "&", "0o444", ")", ">>", "2", "os", ".", "chmod", "(", "file_path", ",", "mode", ")" ]

[ "Grant", "permission", "to", "execute", "a", "file", "." ]

[ "'''Grant permission to execute a file.'''", "# https://stackoverflow.com/a/30463972" ]

[ { "param": "file_path", "type": null } ]

{ "returns": [], "raises": [], "params": [ { "identifier": "file_path", "type": null, "docstring": null, "docstring_tokens": [], "default": null, "is_optional": null } ], "outlier_params": [], "others": [] }

[ "MIT", "BSD-3-Clause" ]

[ "Wait", "until", "a", "given", "time", "." ]

[ "async", "def", "wait_until", "(", "time", ":", "datetime", ".", "datetime", ",", "start", ":", "Optional", "[", "datetime", ".", "datetime", "]", "=", "None", ")", "->", "None", ":", "delay", "=", "time", "-", "(", "start", "or", "datetime", ".", "datetime", ".", "utcnow", "(", ")", ")", "delay_seconds", "=", "delay", ".", "total_seconds", "(", ")", "if", "delay_seconds", ">", "1.0", ":", "await", "asyncio", ".", "sleep", "(", "delay_seconds", ")" ]

[ "Wait", "until", "a", "given", "time", "." ]

[ "\"\"\"\n Wait until a given time.\n\n :param time: A datetime.datetime object to wait until.\n :param start: The start from which to calculate the waiting duration. Defaults to UTC time.\n \"\"\"", "# Incorporate a small delay so we don't rapid-fire the event due to time precision errors" ]

[ { "param": "time", "type": "datetime.datetime" }, { "param": "start", "type": "Optional[datetime.datetime]" } ]

{ "returns": [], "raises": [], "params": [ { "identifier": "time", "type": "datetime.datetime", "docstring": "A datetime.datetime object to wait until.", "docstring_tokens": [ "A", "datetime", ".", "datetime", "object", "to", "wait", "until", "." ], "default": null, "is_optional": null }, { "identifier": "start", "type": "Optional[datetime.datetime]", "docstring": "The start from which to calculate the waiting duration. Defaults to UTC time.", "docstring_tokens": [ "The", "start", "from", "which", "to", "calculate", "the", "waiting", "duration", ".", "Defaults", "to", "UTC", "time", "." ], "default": null, "is_optional": null } ], "outlier_params": [], "others": [] }

[ "MIT" ]

[ "Return", "list", "of", "vertices", "in", "reverse", "topologically", "sorted", "order", "." ]

[ "def", "reverse_topological_sort", "(", "graph", ")", ":", "result", "=", "[", "]", "explored", "=", "set", "(", ")", "dfs_stack", "=", "[", "(", "v", ",", "0", ")", "for", "v", "in", "graph", ".", "vertices", "]", "while", "dfs_stack", ":", "(", "v", ",", "i", ")", "=", "dfs_stack", ".", "pop", "(", ")", "if", "(", "v", ",", "i", ")", "in", "explored", ":", "continue", "explored", ".", "add", "(", "(", "v", ",", "i", ")", ")", "if", "i", "==", "0", ":", "dfs_stack", ".", "extend", "(", "[", "(", "v", ",", "1", ")", "]", "+", "[", "(", "u", ",", "0", ")", "for", "u", "in", "graph", ".", "adjacencies", "(", "v", ")", "]", ")", "elif", "i", "==", "1", ":", "result", ".", "append", "(", "v", ")", "return", "result" ]

[ "Return", "list", "of", "vertices", "in", "reverse", "topologically", "sorted", "order", "." ]

[ "\"\"\"Return list of vertices in reverse topologically sorted order.\n \"\"\"", "# preordering visit", "# postordering visit" ]

[ { "param": "graph", "type": null } ]

{ "returns": [], "raises": [], "params": [ { "identifier": "graph", "type": null, "docstring": null, "docstring_tokens": [], "default": null, "is_optional": null } ], "outlier_params": [], "others": [] }

[ "MIT" ]

[ "Compute", "the", "arithmetic", "mean", "and", "standard", "deviation", "of", "a", "list", "of", "values", ".", "Args", ":", "values", "Iterable", "of", "values", "Returns", ":", "Arithmetic", "mean", "standard", "deviation" ]

[ "def", "compute_avg_dev", "(", "values", ")", ":", "avg", "=", "sum", "(", "values", ")", "/", "len", "(", "values", ")", "var", "=", "0", "for", "value", "in", "values", ":", "var", "+=", "(", "value", "-", "avg", ")", "**", "2", "var", "/=", "len", "(", "values", ")", "-", "1", "return", "avg", ",", "math", ".", "sqrt", "(", "var", ")" ]

[ "Compute", "the", "arithmetic", "mean", "and", "standard", "deviation", "of", "a", "list", "of", "values", "." ]

[ "\"\"\" Compute the arithmetic mean and standard deviation of a list of values.\n Args:\n values Iterable of values\n Returns:\n Arithmetic mean, standard deviation\n \"\"\"" ]

[ { "param": "values", "type": null } ]

{ "returns": [], "raises": [], "params": [ { "identifier": "values", "type": null, "docstring": null, "docstring_tokens": [], "default": null, "is_optional": null } ], "outlier_params": [], "others": [] }

[ "Apache-2.0" ]

[ "Check", "if", "value", "is", "a", "valid", "timestamp", "." ]

[ "def", "is_timestamp", "(", "value", ":", "Any", ")", "->", "bool", ":", "if", "isinstance", "(", "value", ",", "bool", ")", ":", "return", "False", "if", "not", "isinstance", "(", "value", ",", "(", "int", ",", "float", ",", "str", ")", ")", ":", "return", "False", "try", ":", "float", "(", "value", ")", "return", "True", "except", "ValueError", ":", "return", "False" ]

[ "Check", "if", "value", "is", "a", "valid", "timestamp", "." ]

[ "\"\"\"Check if value is a valid timestamp.\"\"\"" ]

[ { "param": "value", "type": "Any" } ]

{ "returns": [], "raises": [], "params": [ { "identifier": "value", "type": "Any", "docstring": null, "docstring_tokens": [], "default": null, "is_optional": null } ], "outlier_params": [], "others": [] }

[ "MIT" ]

[ "Parses", "the", "line", "as", "an", "option", "returning", "the", "key", "/", "value", "pair", "." ]

[ "def", "try_option", "(", "line", ")", ":", "data", "=", "re", ".", "split", "(", "'=>?'", ",", "line", ",", "1", ")", "return", "data", "[", "0", "]", ".", "rstrip", "(", ")", ",", "data", "[", "1", "]", ".", "lstrip", "(", ")" ]

[ "Parses", "the", "line", "as", "an", "option", "returning", "the", "key", "/", "value", "pair", "." ]

[ "\"\"\"Parses the line as an option, returning the key/value pair.\"\"\"", "# should split in two (key/val), but either way use first two elements" ]

[ { "param": "line", "type": null } ]

{ "returns": [], "raises": [], "params": [ { "identifier": "line", "type": null, "docstring": null, "docstring_tokens": [], "default": null, "is_optional": null } ], "outlier_params": [], "others": [] }

[ "BSD-3-Clause-No-Nuclear-License-2014", "BSD-3-Clause" ]

[ "Returns", "a", "list", "of", "IPRs", "related", "to", "doc", "aliases" ]

[ "def", "iprs_from_docs", "(", "aliases", ",", "**", "kwargs", ")", ":", "iprdocrels", "=", "[", "]", "for", "alias", "in", "aliases", ":", "if", "alias", ".", "document", ".", "ipr", "(", "**", "kwargs", ")", ":", "iprdocrels", "+=", "alias", ".", "document", ".", "ipr", "(", "**", "kwargs", ")", "return", "list", "(", "set", "(", "[", "i", ".", "disclosure", "for", "i", "in", "iprdocrels", "]", ")", ")" ]

[ "Returns", "a", "list", "of", "IPRs", "related", "to", "doc", "aliases" ]

[ "\"\"\"Returns a list of IPRs related to doc aliases\"\"\"" ]

[ { "param": "aliases", "type": null } ]

{ "returns": [], "raises": [], "params": [ { "identifier": "aliases", "type": null, "docstring": null, "docstring_tokens": [], "default": null, "is_optional": null } ], "outlier_params": [], "others": [] }

[ "Apache-2.0" ]

[ "This", "model", "is", "intended", "for", "evaluation", "of", "rosdiscover", "on", "detecting", "misconfigurations", ".", "IT", "SHOULD", "NOT", "BE", "USED", "IN", "GENERAL", ".", "This", "model", "subscribes", "and", "publishes", "to", "topics", "that", "are", "passed", "in", "as", "parameters", ".", "In", "this", "way", "we", "can", "easily", "construct", "a", "node", "that", "can", "be", "used", "to", "reproduce", "a", "configuration", "error", "that", "exists", "in", "our", "database", "." ]

[ "def", "error_reproducer", "(", "c", ":", "NodeContext", ")", ":", "topics", "=", "c", ".", "read", "(", "\"~topic\"", ",", "[", "]", ")", "for", "t", "in", "topics", ":", "if", "t", "[", "\"direction\"", "]", "==", "'pub'", ":", "c", ".", "pub", "(", "t", "[", "\"name\"", "]", ",", "t", "[", "\"type\"", "]", ")", "elif", "t", "[", "\"direction\"", "]", "==", "'sub'", ":", "c", ".", "sub", "(", "t", "[", "\"name\"", "]", ",", "t", "[", "\"type\"", "]", ")" ]

[ "This", "model", "is", "intended", "for", "evaluation", "of", "rosdiscover", "on", "detecting", "misconfigurations", "." ]

[ "\"\"\"\n This model is intended for evaluation of rosdiscover on\n detecting misconfigurations. IT SHOULD NOT BE USED IN GENERAL.\n\n This model subscribes and publishes to topics that are passed\n in as parameters. In this way, we can easily construct a node\n that can be used to reproduce a configuration error that exists\n in our database.\n \"\"\"" ]

[ { "param": "c", "type": "NodeContext" } ]

{ "returns": [], "raises": [], "params": [ { "identifier": "c", "type": "NodeContext", "docstring": null, "docstring_tokens": [], "default": null, "is_optional": null } ], "outlier_params": [], "others": [] }

[ "Apache-2.0" ]

[ "Initialize", "a", "UseragentRuleObjectConfiguration", "object", "from", "a", "json", "dictionary", "." ]

[ "def", "from_dict", "(", "cls", ",", "_dict", ":", "Dict", ")", "->", "'UseragentRuleObjectConfiguration'", ":", "args", "=", "{", "}", "if", "'target'", "in", "_dict", ":", "args", "[", "'target'", "]", "=", "_dict", ".", "get", "(", "'target'", ")", "else", ":", "raise", "ValueError", "(", "'Required property \\'target\\' not present in UseragentRuleObjectConfiguration JSON'", ")", "if", "'value'", "in", "_dict", ":", "args", "[", "'value'", "]", "=", "_dict", ".", "get", "(", "'value'", ")", "else", ":", "raise", "ValueError", "(", "'Required property \\'value\\' not present in UseragentRuleObjectConfiguration JSON'", ")", "return", "cls", "(", "**", "args", ")" ]

[ "Initialize", "a", "UseragentRuleObjectConfiguration", "object", "from", "a", "json", "dictionary", "." ]

[ "\"\"\"Initialize a UseragentRuleObjectConfiguration object from a json dictionary.\"\"\"" ]

[ { "param": "cls", "type": null }, { "param": "_dict", "type": "Dict" } ]

{ "returns": [], "raises": [], "params": [ { "identifier": "cls", "type": null, "docstring": null, "docstring_tokens": [], "default": null, "is_optional": null }, { "identifier": "_dict", "type": "Dict", "docstring": null, "docstring_tokens": [], "default": null, "is_optional": null } ], "outlier_params": [], "others": [] }

[ "MIT" ]

[ "Sorts", "the", "given", "directed", "tree", "'", "s", "branch", ".", "Sorting", "here", "means", "that", "at", "every", "level", "(", "starting", "from", "the", "root", "node", ")", "the", "nodes", "should", "follow", "an", "increasing", "order", "at", "the", "count", "of", "their", "children", "." ]

[ "def", "sort_tree", "(", "t", ",", "node", ")", ":", "node", ".", "ordervect", "=", "[", "len", "(", "node", ".", "children_list", ")", "]", "if", "node", ".", "children_list", ":", "for", "n", "in", "node", ".", "children_list", ":", "sort_tree", "(", "t", ",", "t", "[", "n", "]", ")", "node", ".", "ordervect", ".", "append", "(", "t", "[", "n", "]", ".", "ordervect", ")", "if", "len", "(", "node", ".", "children_list", ")", ">", "1", ":", "node", ".", "children_list", ",", "node", ".", "ordervect", "[", "1", ":", "]", "=", "(", "list", "(", "x", ")", "for", "x", "in", "zip", "(", "*", "sorted", "(", "zip", "(", "node", ".", "children_list", ",", "node", ".", "ordervect", "[", "1", ":", "]", ")", ",", "key", "=", "lambda", "pair", ":", "t", "[", "pair", "[", "0", "]", "]", ".", "ordervect", ")", ")", ")" ]

[ "Sorts", "the", "given", "directed", "tree", "'", "s", "branch", "." ]

[ "\"\"\"Sorts the given directed tree's branch.\n\n Sorting here means that at every level (starting from the root node) the nodes should follow an increasing order\n at the count of their children.\n\n Args:\n t: a dictionary that contains the nodes of a labeled tree\n node: the actual node of the tree (Node object)\n \"\"\"", "# iterate through the children", "# if there is more then one children, sort the children list and the ordervect at the same time (the keys are", "# the elements of the ordervect)" ]

[ { "param": "t", "type": null }, { "param": "node", "type": null } ]

{ "returns": [], "raises": [], "params": [ { "identifier": "t", "type": null, "docstring": "a dictionary that contains the nodes of a labeled tree", "docstring_tokens": [ "a", "dictionary", "that", "contains", "the", "nodes", "of", "a", "labeled", "tree" ], "default": null, "is_optional": null }, { "identifier": "node", "type": null, "docstring": "the actual node of the tree (Node object)", "docstring_tokens": [ "the", "actual", "node", "of", "the", "tree", "(", "Node", "object", ")" ], "default": null, "is_optional": null } ], "outlier_params": [], "others": [] }

[ "Apache-2.0", "CC-BY-4.0" ]

[ "check", "if", "an", "ip", "address", "of", "the", "type", "ipv4", "is", "valid" ]

[ "def", "is_valid_ipv4_address", "(", "ip_address", ")", ":", "try", ":", "socket", ".", "inet_pton", "(", "socket", ".", "AF_INET", ",", "ip_address", ")", "except", "AttributeError", ":", "try", ":", "socket", ".", "inet_aton", "(", "ip_address", ")", "except", "(", "OSError", ",", "socket", ".", "error", ")", ":", "return", "False", "return", "ip_address", ".", "count", "(", "\".\"", ")", "==", "3", "except", "(", "OSError", ",", "socket", ".", "error", ")", ":", "return", "False", "return", "True" ]

[ "check", "if", "an", "ip", "address", "of", "the", "type", "ipv4", "is", "valid" ]

[ "\"\"\"\n check if an ip address of the type ipv4\n is valid\n \"\"\"" ]

[ { "param": "ip_address", "type": null } ]

{ "returns": [], "raises": [], "params": [ { "identifier": "ip_address", "type": null, "docstring": null, "docstring_tokens": [], "default": null, "is_optional": null } ], "outlier_params": [], "others": [] }

[ "BSD-3-Clause" ]

[ "Check", "that", "a", "directory", "is", "exists", "and", "is", "readable" ]

[ "def", "readable_directory", "(", "directory", ":", "str", ")", "->", "str", ":", "if", "not", "os", ".", "path", ".", "isdir", "(", "directory", ")", ":", "msg", "=", "\"directory:{0} is not a valid path\"", ".", "format", "(", "directory", ")", "raise", "argparse", ".", "ArgumentTypeError", "(", "msg", ")", "elif", "not", "os", ".", "access", "(", "directory", ",", "os", ".", "R_OK", ")", ":", "msg", "=", "\"directory:{0} cannot be read\"", ".", "format", "(", "directory", ")", "raise", "argparse", ".", "ArgumentTypeError", "(", "msg", ")", "else", ":", "return", "directory" ]

[ "Check", "that", "a", "directory", "is", "exists", "and", "is", "readable" ]

[ "\"\"\"\n Check that a directory is exists and is readable\n \"\"\"" ]

[ { "param": "directory", "type": "str" } ]

{ "returns": [], "raises": [], "params": [ { "identifier": "directory", "type": "str", "docstring": null, "docstring_tokens": [], "default": null, "is_optional": null } ], "outlier_params": [], "others": [] }

[ "Apache-2.0" ]

[ "Write", "a", "list", "of", "dependencies", "to", "standard", "out", "." ]

[ "def", "_write_dependencies", "(", "spec", ")", ":", "if", "not", "spec", ".", "imports", ":", "return", "dependencies", "=", "sorted", "(", "spec", ".", "imports", ".", "dependencies", ")", "for", "resolved_file_name", "in", "dependencies", ":", "print", "(", "resolved_file_name", ")" ]

[ "Write", "a", "list", "of", "dependencies", "to", "standard", "out", "." ]

[ "# type: (syntax.IDLSpec) -> None", "\"\"\"Write a list of dependencies to standard out.\"\"\"" ]

[ { "param": "spec", "type": null } ]

{ "returns": [], "raises": [], "params": [ { "identifier": "spec", "type": null, "docstring": null, "docstring_tokens": [], "default": null, "is_optional": null } ], "outlier_params": [], "others": [] }

[ "MIT" ]

[ "Convert", "output", "from", "uwnet", ".", "columns", "to", "have", "proper", "SI", "units" ]

[ "def", "to_normal_units_nn_columns", "(", "ds", ")", ":", "scales", "=", "{", "'FQT'", ":", "1", "/", "86400", "/", "1000", ",", "'FSL'", ":", "1", "/", "86400", ",", "'Q1NN'", ":", "1", "/", "86400", "/", "1000", ",", "'qt'", ":", "1", "/", "1000", ",", "'qtOBS'", ":", "1", "/", "1000", ",", "'Q2NN'", ":", "1", "/", "86400", "/", "1000", ",", "}", "for", "key", ",", "scale", "in", "scales", ".", "items", "(", ")", ":", "if", "key", "in", "ds", ":", "ds", "=", "ds", ".", "assign", "(", "**", "{", "key", ":", "ds", "[", "key", "]", "*", "scale", "}", ")", "return", "ds" ]

[ "Convert", "output", "from", "uwnet", ".", "columns", "to", "have", "proper", "SI", "units" ]

[ "\"\"\"Convert output from uwnet.columns to have proper SI units\"\"\"" ]

[ { "param": "ds", "type": null } ]

{ "returns": [], "raises": [], "params": [ { "identifier": "ds", "type": null, "docstring": null, "docstring_tokens": [], "default": null, "is_optional": null } ], "outlier_params": [], "others": [] }

[ "MIT" ]

[ "Applies", "Xavier", "initialization", "to", "linear", "modules", "." ]

[ "def", "xavier", "(", "m", ":", "nn", ".", "Module", ")", "->", "None", ":", "if", "m", ".", "__class__", ".", "__name__", "==", "'Linear'", ":", "fan_in", "=", "m", ".", "weight", ".", "data", ".", "size", "(", "1", ")", "fan_out", "=", "m", ".", "weight", ".", "data", ".", "size", "(", "0", ")", "std", "=", "1.0", "*", "math", ".", "sqrt", "(", "2.0", "/", "(", "fan_in", "+", "fan_out", ")", ")", "a", "=", "math", ".", "sqrt", "(", "3.0", ")", "*", "std", "m", ".", "weight", ".", "data", ".", "uniform_", "(", "-", "a", ",", "a", ")", "if", "m", ".", "bias", "is", "not", "None", ":", "m", ".", "bias", ".", "data", ".", "fill_", "(", "0.0", ")" ]

[ "Applies", "Xavier", "initialization", "to", "linear", "modules", "." ]

[ "\"\"\"\n Applies Xavier initialization to linear modules.\n\n :param m: the module to be initialized\n\n Example::\n >>> net = nn.Sequential(nn.Linear(10, 10), nn.ReLU())\n >>> net.apply(xavier)\n \"\"\"" ]

[ { "param": "m", "type": "nn.Module" } ]

{ "returns": [], "raises": [], "params": [ { "identifier": "m", "type": "nn.Module", "docstring": "the module to be initialized\nExample::\n>>> net = nn.Sequential(nn.Linear(10, 10), nn.ReLU())\n>>> net.apply(xavier)", "docstring_tokens": [ "the", "module", "to", "be", "initialized", "Example", "::", ">>>", "net", "=", "nn", ".", "Sequential", "(", "nn", ".", "Linear", "(", "10", "10", ")", "nn", ".", "ReLU", "()", ")", ">>>", "net", ".", "apply", "(", "xavier", ")" ], "default": null, "is_optional": null } ], "outlier_params": [], "others": [] }

[ "MIT" ]

[ "Converts", "a", "velocity", "of", "a", "motor", "from", "a", "pulse", "divisor", "exponent", "and", "a", "portion", "of", "`", "__VELOCITY_PORTIONS", "`", "into", "units", "of", "fullsteps", "per", "second", "." ]

[ "def", "__velocity_external", "(", "cls", ",", "pulse_divisor_exponent", ":", "int", ",", "portion", ":", "int", ",", "microstep_resolution", ":", "int", ")", "->", "float", ":", "return", "(", "portion", "*", "cls", ".", "__VELOCITY_DIVIDEND", "/", "(", "cls", ".", "__VELOCITY_PORTIONS", "*", "cls", ".", "__DIVISOR_BASE", "**", "pulse_divisor_exponent", ")", "/", "microstep_resolution", ")" ]

[ "Converts", "a", "velocity", "of", "a", "motor", "from", "a", "pulse", "divisor", "exponent", "and", "a", "portion", "of", "`", "__VELOCITY_PORTIONS", "`", "into", "units", "of", "fullsteps", "per", "second", "." ]

[ "\"\"\"\r\n Converts a velocity of a motor from a pulse divisor exponent and a portion of\r\n `__VELOCITY_PORTIONS` into units of fullsteps per second.\r\n \"\"\"" ]

[ { "param": "cls", "type": null }, { "param": "pulse_divisor_exponent", "type": "int" }, { "param": "portion", "type": "int" }, { "param": "microstep_resolution", "type": "int" } ]

{ "returns": [], "raises": [], "params": [ { "identifier": "cls", "type": null, "docstring": null, "docstring_tokens": [], "default": null, "is_optional": null }, { "identifier": "pulse_divisor_exponent", "type": "int", "docstring": null, "docstring_tokens": [], "default": null, "is_optional": null }, { "identifier": "portion", "type": "int", "docstring": null, "docstring_tokens": [], "default": null, "is_optional": null }, { "identifier": "microstep_resolution", "type": "int", "docstring": null, "docstring_tokens": [], "default": null, "is_optional": null } ], "outlier_params": [], "others": [] }

[ "Apache-2.0" ]

[ "Function", "to", "check", "if", "pool", "folder", "exist", "on", "server" ]

[ "def", "check_for_pool", "(", "host", ",", "uuid", ")", ":", "cmd", "=", "\"test -e /mnt/daos/\"", "+", "uuid", "resp", "=", "subprocess", ".", "call", "(", "[", "\"ssh\"", ",", "host", ",", "cmd", "]", ")", "if", "resp", "==", "0", ":", "print", "(", "'%s exists'", "%", "uuid", ")", "else", ":", "print", "(", "'%s does not exist'", "%", "uuid", ")", "return", "resp" ]

[ "Function", "to", "check", "if", "pool", "folder", "exist", "on", "server" ]

[ "\"\"\"\n Function to check if pool folder exist on server\n Args:\n host: Server host name\n uuid: Pool uuid to check if exists\n return:\n resp: subprocess return code\n \"\"\"" ]

[ { "param": "host", "type": null }, { "param": "uuid", "type": null } ]

{ "returns": [], "raises": [], "params": [ { "identifier": "host", "type": null, "docstring": "Server host name", "docstring_tokens": [ "Server", "host", "name" ], "default": null, "is_optional": null }, { "identifier": "uuid", "type": null, "docstring": "Pool uuid to check if exists", "docstring_tokens": [ "Pool", "uuid", "to", "check", "if", "exists" ], "default": null, "is_optional": null } ], "outlier_params": [], "others": [] }

[ "MIT" ]

[ "Mostly", "used", "to", "ensure", "if", "there", "is", "an", "opening", "brace", "then", "there", "is", "a", "matching", "closing", "brace", "somewhere", "in", "the", "expression", ".", "This", "function", "also", "saves", "the", "location", "of", "the", "last", "found", "closing", "brace", "into", "MatchParenIndex", ".", "If", "we", "start", "looking", "for", "another", "closing", "brace", "then", "we", "start", "looking", "from", "MatchParenIndex", "." ]

[ "def", "must_be", "(", "_", ",", "c", ")", ":", "index", "=", "_", ".", "NextTokenIndex", "if", "_", ".", "MatchParenIndex", ">", "_", ".", "NextTokenIndex", ":", "index", "=", "_", ".", "MatchParenIndex", "for", "i", "in", "range", "(", "index", ",", "len", "(", "_", ".", "token_stream", ")", ")", ":", "if", "_", ".", "token_stream", "[", "i", "]", "[", "1", "]", "==", "c", ":", "_", ".", "MatchParenIndex", "=", "i", "return", "True", "raise", "Exception", "(", "\"Missing closing '{}'\"", ".", "format", "(", "c", ")", ")" ]

[ "NOT", "IN", "USE", "ANYMORE", ":", "I", "changed", "how", "my", "parsing", "works", "to", "not", "use", "this", "." ]

[ "\"\"\" \n NOT IN USE ANYMORE: I changed how my parsing works to not use this.\n\n I should probably have some sort of check, but I'll worry about that\n later. It works for now.\n\n Mostly used to ensure if there is an opening brace, then there is \n a matching closing brace somewhere in the expression. \n\n This function also saves the location of the last found closing brace\n into MatchParenIndex. If we start looking for another closing brace, \n then we start looking from MatchParenIndex.\n \"\"\"", "#print(\"MatchParenIndex\",MatchParenIndex)", "#print(\"* _.NextToken\",_.NextToken)", "#print(\"* NextTokenIndex\", NextTokenIndex)", "#print(\"* Index\", index)", "#GetNextToken()", "#std.write(\"Found closing paren\")", "#print(\"* _.NextToken\",_.NextToken)", "#print(\"* NextTokenIndex\", NextTokenIndex)", "#print(\"* Index\", index)" ]

[ { "param": "_", "type": null }, { "param": "c", "type": null } ]

{ "returns": [], "raises": [], "params": [ { "identifier": "_", "type": null, "docstring": null, "docstring_tokens": [], "default": null, "is_optional": null }, { "identifier": "c", "type": null, "docstring": null, "docstring_tokens": [], "default": null, "is_optional": null } ], "outlier_params": [], "others": [] }

[ "BSD-3-Clause" ]

[ "there", "is", "an", "in", "and", "out", "dependency" ]

[ "def", "is_depend_in_out", "(", "var", ":", "Variable", ",", "in_deps", ":", "List", "[", "Tuple", "[", "str", ",", "str", ",", "Dependency", "]", "]", ",", "out_deps", ":", "List", "[", "Tuple", "[", "str", ",", "str", ",", "Dependency", "]", "]", ")", "->", "bool", ":", "for", "in_dep", "in", "in_deps", ":", "for", "out_dep", "in", "out_deps", ":", "if", "var", ".", "name", "==", "in_dep", "[", "2", "]", ".", "var_name", "and", "in_dep", "[", "2", "]", ".", "var_name", "==", "out_dep", "[", "2", "]", ".", "var_name", ":", "return", "True", "return", "False" ]

[ "there", "is", "an", "in", "and", "out", "dependency" ]

[ "\"\"\"there is an in and out dependency\n\n :param var: Variable\n :param in_deps: in dependencies\n :param out_deps: out dependencies\n :return: true if dependency is both in and out\n \"\"\"" ]

[ { "param": "var", "type": "Variable" }, { "param": "in_deps", "type": "List[Tuple[str, str, Dependency]]" }, { "param": "out_deps", "type": "List[Tuple[str, str, Dependency]]" } ]

{ "returns": [ { "docstring": "true if dependency is both in and out", "docstring_tokens": [ "true", "if", "dependency", "is", "both", "in", "and", "out" ], "type": null } ], "raises": [], "params": [ { "identifier": "var", "type": "Variable", "docstring": null, "docstring_tokens": [ "None" ], "default": null, "is_optional": null }, { "identifier": "in_deps", "type": "List[Tuple[str, str, Dependency]]", "docstring": null, "docstring_tokens": [ "None" ], "default": null, "is_optional": null }, { "identifier": "out_deps", "type": "List[Tuple[str, str, Dependency]]", "docstring": null, "docstring_tokens": [ "None" ], "default": null, "is_optional": null } ], "outlier_params": [], "others": [] }

[ "MIT" ]

[ "Records", "imports", "for", "custom", "annotations", "in", "the", "given", "namespace", "." ]

[ "def", "record_custom_annotation_imports", "(", "annotation", ",", "namespace", ")", ":", "if", "annotation", ".", "annotation_type", ".", "namespace", ".", "name", "!=", "namespace", ".", "name", ":", "namespace", ".", "add_imported_namespace", "(", "annotation", ".", "annotation_type", ".", "namespace", ",", "imported_annotation_type", "=", "True", ")", "if", "annotation", ".", "namespace", ".", "name", "!=", "namespace", ".", "name", ":", "namespace", ".", "add_imported_namespace", "(", "annotation", ".", "namespace", ",", "imported_annotation", "=", "True", ")" ]

[ "Records", "imports", "for", "custom", "annotations", "in", "the", "given", "namespace", "." ]

[ "\"\"\"\n Records imports for custom annotations in the given namespace.\n\n \"\"\"", "# first, check the annotation *type*", "# second, check if we need to import the annotation itself", "# the annotation namespace is currently not actually used in the", "# backends, which reconstruct the annotation from the annotation", "# type directly. This could be changed in the future, and at", "# the IR level it makes sense to include the dependency" ]

[ { "param": "annotation", "type": null }, { "param": "namespace", "type": null } ]

{ "returns": [], "raises": [], "params": [ { "identifier": "annotation", "type": null, "docstring": null, "docstring_tokens": [], "default": null, "is_optional": null }, { "identifier": "namespace", "type": null, "docstring": null, "docstring_tokens": [], "default": null, "is_optional": null } ], "outlier_params": [], "others": [] }

[ "MIT" ]

[ "This", "function", "divides", "the", "number", "of", "balls", "remaining", "by", "5", "with", "modulus", "so", "that", "the", "computer", "ends", "up", "winning", "by", "always", "taking", "the", "remainder", "of", "the", "division", "." ]

[ "def", "player_2_turn", "(", "num_balls", ")", ":", "player2", "=", "num_balls", "%", "5", "if", "player2", "==", "0", ":", "player2", "=", "random", ".", "randrange", "(", "1", ",", "4", ")", "num_balls", "=", "num_balls", "-", "player2", "print", "(", "\"The computer takes\"", ",", "player2", ",", "\"balls\"", ")", "print", "(", "\"there are\"", ",", "num_balls", ",", "\"left\"", ")", "return", "num_balls" ]

[ "This", "function", "divides", "the", "number", "of", "balls", "remaining", "by", "5", "with", "modulus", "so", "that", "the", "computer", "ends", "up", "winning", "by", "always", "taking", "the", "remainder", "of", "the", "division", "." ]

[ "\"\"\"\n This function divides the number of balls remaining by 5 with modulus so that the computer ends up winning by always taking the remainder of the division.\n :param num_balls: integer. number of balls that changes as user and computer pick\n :return: num_balls\n \"\"\"", "# modulus to calcuate how many balls for the computer to pick", "# if the result from modulus is 0 then something else happens", "# a random number is assigned to player2", "# recalculating the number of balls after the computer picks", "# telling user how many balls they pick", "# telling user how many balls are remaining" ]

[ { "param": "num_balls", "type": null } ]

{ "returns": [ { "docstring": null, "docstring_tokens": [ "None" ], "type": null } ], "raises": [], "params": [ { "identifier": "num_balls", "type": null, "docstring": "integer. number of balls that changes as user and computer pick", "docstring_tokens": [ "integer", ".", "number", "of", "balls", "that", "changes", "as", "user", "and", "computer", "pick" ], "default": null, "is_optional": null } ], "outlier_params": [], "others": [] }

[ "MIT" ]

[ "Return", "element", "of", "abi", "(", "return", "None", "if", "fails", "to", "find", ")" ]

[ "def", "abi_get_element_by_name", "(", "abi", ",", "name", ")", ":", "if", "(", "abi", "and", "\"abi\"", "in", "abi", ")", ":", "for", "a", "in", "abi", "[", "\"abi\"", "]", ":", "if", "(", "\"name\"", "in", "a", "and", "a", "[", "\"name\"", "]", "==", "name", ")", ":", "return", "a", "return", "None" ]

[ "Return", "element", "of", "abi", "(", "return", "None", "if", "fails", "to", "find", ")" ]

[ "\"\"\" Return element of abi (return None if fails to find) \"\"\"" ]

[ { "param": "abi", "type": null }, { "param": "name", "type": null } ]

{ "returns": [], "raises": [], "params": [ { "identifier": "abi", "type": null, "docstring": null, "docstring_tokens": [], "default": null, "is_optional": null }, { "identifier": "name", "type": null, "docstring": null, "docstring_tokens": [], "default": null, "is_optional": null } ], "outlier_params": [], "others": [] }

[ "MIT" ]

[ "Display", "rate", "limit", "if", "it", "isn", "'", "t", "at", "maximum", ";", "return", "available", "count", "for", "convenience" ]

[ "def", "display_rate_limit", "(", "tag", ",", "limit", ")", ":", "if", "limit", "[", "\"remaining\"", "]", "!=", "limit", "[", "\"limit\"", "]", ":", "print", "(", "limit", "[", "\"remaining\"", "]", ",", "\"out of\"", ",", "limit", "[", "\"limit\"", "]", ",", "tag", ",", "\"queries available\"", ")", "reset_time", "=", "limit", "[", "\"reset\"", "]", "print", "(", "\" Will reset in\"", ",", "reset_time", "-", "time", ".", "time", "(", ")", ",", "\"seconds, at\"", ",", "time", ".", "ctime", "(", "reset_time", ")", ")", "return", "limit", "[", "\"remaining\"", "]" ]

[ "Display", "rate", "limit", "if", "it", "isn", "'", "t", "at", "maximum", ";", "return", "available", "count", "for", "convenience" ]

[ "\"\"\"Display rate limit if it isn't at maximum; return available count for convenience\"\"\"" ]

[ { "param": "tag", "type": null }, { "param": "limit", "type": null } ]

{ "returns": [], "raises": [], "params": [ { "identifier": "tag", "type": null, "docstring": null, "docstring_tokens": [], "default": null, "is_optional": null }, { "identifier": "limit", "type": null, "docstring": null, "docstring_tokens": [], "default": null, "is_optional": null } ], "outlier_params": [], "others": [] }

[ "Apache-2.0" ]

[ "Write", "the", "configuration", "to", "target", "." ]

[ "def", "write_config", "(", "config", ":", "str", ",", "private_key", ":", "str", ",", "certificate", ":", "str", ",", "target", ":", "Path", ")", ":", "with", "open", "(", "target", ",", "mode", "=", "'w+t'", ")", "as", "f", ":", "f", ".", "writelines", "(", "config", ")", "f", ".", "writelines", "(", "f\"\\n<key>\\n{private_key}\\n</key>\\n\"", ")", "f", ".", "writelines", "(", "f\"\\n<cert>\\n{certificate}\\n</cert>\\n\"", ")" ]

[ "Write", "the", "configuration", "to", "target", "." ]

[ "\"\"\"\n Write the configuration to target.\n \"\"\"" ]

[ { "param": "config", "type": "str" }, { "param": "private_key", "type": "str" }, { "param": "certificate", "type": "str" }, { "param": "target", "type": "Path" } ]

{ "returns": [], "raises": [], "params": [ { "identifier": "config", "type": "str", "docstring": null, "docstring_tokens": [], "default": null, "is_optional": null }, { "identifier": "private_key", "type": "str", "docstring": null, "docstring_tokens": [], "default": null, "is_optional": null }, { "identifier": "certificate", "type": "str", "docstring": null, "docstring_tokens": [], "default": null, "is_optional": null }, { "identifier": "target", "type": "Path", "docstring": null, "docstring_tokens": [], "default": null, "is_optional": null } ], "outlier_params": [], "others": [] }

[ "MIT" ]

[ "Method", "that", "reads", "the", "possible", "surnames", "from", "a", "file" ]

[ "def", "readSurnames", "(", ")", ":", "surnamesRead", "=", "[", "]", "with", "open", "(", "\"Files/Surnames.txt\"", ",", "'r'", ",", "encoding", "=", "'utf8'", ")", "as", "f", ":", "for", "line", "in", "f", ":", "if", "line", "==", "\"\\n\"", ":", "continue", "surnamesRead", ".", "append", "(", "line", ".", "rstrip", "(", "'\\n'", ")", ".", "rstrip", "(", ")", ".", "lstrip", "(", ")", ")", "f", ".", "close", "(", ")", "return", "surnamesRead" ]

[ "Method", "that", "reads", "the", "possible", "surnames", "from", "a", "file" ]

[ "\"\"\"\n Method that reads the possible surnames from a file\n :return: a list containing the surnames\n \"\"\"" ]

[]

{ "returns": [ { "docstring": "a list containing the surnames", "docstring_tokens": [ "a", "list", "containing", "the", "surnames" ], "type": null } ], "raises": [], "params": [], "outlier_params": [], "others": [] }

[ "MIT" ]

[ "Checks", "if", "the", "number", "is", "odd", "." ]

[ "def", "is_odd", "(", "number", ")", ":", "return", "(", "number", "%", "2", "!=", "0", ")" ]

[ "Checks", "if", "the", "number", "is", "odd", "." ]

[ "\"\"\"\n\t\tChecks if the number is odd.\n\t\t:param number: Number.\n\t\t:return: True if is odd, false if it is even.\n\t\t\"\"\"" ]

[ { "param": "number", "type": null } ]

{ "returns": [ { "docstring": "True if is odd, false if it is even.", "docstring_tokens": [ "True", "if", "is", "odd", "false", "if", "it", "is", "even", "." ], "type": null } ], "raises": [], "params": [ { "identifier": "number", "type": null, "docstring": null, "docstring_tokens": [ "None" ], "default": null, "is_optional": null } ], "outlier_params": [], "others": [] }

[ "Apache-2.0" ]

[ "Check", "if", "the", "Makefile", "output", "can", "be", "parsed", "and", "transformed", "automatically", ".", "Raises", "exceptions", "if", "something", "looks", "weird" ]

[ "def", "check_debugshell_and_makefile", "(", "makeoutput", ")", ":", "if", "(", "not", "makeoutput", "or", "not", "(", "makeoutput", ".", "startswith", "(", "\"make: Entering directory \"", ")", "or", "makeoutput", ".", "startswith", "(", "\"make[1]: Entering directory \"", ")", ")", ")", ":", "raise", "Exception", "(", "\"Directory changes cannot be recognized: \"", "+", "makeoutput", "[", "0", ":", "35", "]", ")" ]

[ "Check", "if", "the", "Makefile", "output", "can", "be", "parsed", "and", "transformed", "automatically", "." ]

[ "\"\"\"\n Check if the Makefile output can be parsed and transformed automatically.\n Raises exceptions, if something looks weird\n \"\"\"", "# makeoutput must start with directory information.", "# Reason: The --print-directory flag for make flag was given" ]

[ { "param": "makeoutput", "type": null } ]

{ "returns": [], "raises": [], "params": [ { "identifier": "makeoutput", "type": null, "docstring": null, "docstring_tokens": [], "default": null, "is_optional": null } ], "outlier_params": [], "others": [] }

[ "MIT" ]

[ "Method", "to", "convert", "the", "entrez", "genes", "to", "symbols" ]

[ "def", "convert_e2s", "(", "cls", ",", "geneset", ":", "pd", ".", "DataFrame", ",", "tsv_data", ":", "pd", ".", "DataFrame", ",", "entrez_col", ":", "str", "=", "\"NCBI Gene ID\"", ",", "symbol_col", ":", "str", "=", "\"Approved symbol\"", ")", "->", "list", ":", "logging", ".", "info", "(", "\"Converting Entrez ID -> Symbols\"", ")", "unknown_counter", "=", "0", "geneset_symbol", "=", "[", "]", "for", "i", "in", "geneset", ":", "name", "=", "tsv_data", "[", "tsv_data", "[", "entrez_col", "]", "==", "int", "(", "i", ")", "]", "[", "symbol_col", "]", ".", "values", ".", "tolist", "(", ")", "if", "len", "(", "name", ")", ">", "0", ":", "geneset_symbol", ".", "append", "(", "str", "(", "name", "[", "0", "]", ")", ")", "else", ":", "unknown_counter", "+=", "1", "geneset_symbol", ".", "append", "(", "\"<\"", "+", "i", "+", "\">\"", ")", "if", "unknown_counter", ">", "0", ":", "logging", ".", "warning", "(", "\"%d/%d terms that couldn't be mapped\"", "%", "(", "unknown_counter", ",", "len", "(", "geneset", ")", ")", ")", "return", "geneset_symbol" ]

[ "Method", "to", "convert", "the", "entrez", "genes", "to", "symbols" ]

[ "\"\"\"\n Method to convert the entrez genes to symbols\n\n :param tsv_data: the dataframe to work on\n :param symbol_col: the column containing the symbols\n :param entrez_col: the column containing the entrez ID\n :param geneset: column containing the entrez to convert\n :return: list containing the string names\n\n Example\n _______\n >>> gmt_data = rc.ReadGmt(\".gmt\", True).get_data()\n >>> converted = []\n >>> for k, d in gmt_data.items():\n >>> converted[k] = Converters.convert_e2s(d[\"genes\"], tsv_data,entrez_col, symbol_col)\n\n \"\"\"" ]

[ { "param": "cls", "type": null }, { "param": "geneset", "type": "pd.DataFrame" }, { "param": "tsv_data", "type": "pd.DataFrame" }, { "param": "entrez_col", "type": "str" }, { "param": "symbol_col", "type": "str" } ]

{ "returns": [ { "docstring": "list containing the string names\nExample\n>>> gmt_data = rc.ReadGmt(\".gmt\", True).get_data()\n>>> converted = []\n>>> for k, d in gmt_data.items():\n>>> converted[k] = Converters.convert_e2s(d[\"genes\"], tsv_data,entrez_col, symbol_col)", "docstring_tokens": [ "list", "containing", "the", "string", "names", "Example", ">>>", "gmt_data", "=", "rc", ".", "ReadGmt", "(", "\"", ".", "gmt", "\"", "True", ")", ".", "get_data", "()", ">>>", "converted", "=", "[]", ">>>", "for", "k", "d", "in", "gmt_data", ".", "items", "()", ":", ">>>", "converted", "[", "k", "]", "=", "Converters", ".", "convert_e2s", "(", "d", "[", "\"", "genes", "\"", "]", "tsv_data", "entrez_col", "symbol_col", ")" ], "type": null } ], "raises": [], "params": [ { "identifier": "cls", "type": null, "docstring": null, "docstring_tokens": [], "default": null, "is_optional": null }, { "identifier": "geneset", "type": "pd.DataFrame", "docstring": "column containing the entrez to convert", "docstring_tokens": [ "column", "containing", "the", "entrez", "to", "convert" ], "default": null, "is_optional": null }, { "identifier": "tsv_data", "type": "pd.DataFrame", "docstring": "the dataframe to work on", "docstring_tokens": [ "the", "dataframe", "to", "work", "on" ], "default": null, "is_optional": null }, { "identifier": "entrez_col", "type": "str", "docstring": "the column containing the entrez ID", "docstring_tokens": [ "the", "column", "containing", "the", "entrez", "ID" ], "default": null, "is_optional": null }, { "identifier": "symbol_col", "type": "str", "docstring": "the column containing the symbols", "docstring_tokens": [ "the", "column", "containing", "the", "symbols" ], "default": null, "is_optional": null } ], "outlier_params": [], "others": [] }

[ "MIT" ]

[ "Returns", "the", "length", "(", "number", "of", "letters", ")", "in", "the", "current", "hand", ".", "hand", ":", "dictionary", "(", "string", "int", ")", "returns", ":", "integer" ]

[ "def", "calculateHandlen", "(", "hand", ")", ":", "count", "=", "0", "for", "i", "in", "hand", ":", "count", "+=", "hand", "[", "i", "]", "return", "count" ]

[ "Returns", "the", "length", "(", "number", "of", "letters", ")", "in", "the", "current", "hand", "." ]

[ "\"\"\" \n Returns the length (number of letters) in the current hand.\n \n hand: dictionary (string int)\n returns: integer\n \"\"\"" ]

[ { "param": "hand", "type": null } ]

{ "returns": [], "raises": [], "params": [ { "identifier": "hand", "type": null, "docstring": null, "docstring_tokens": [], "default": null, "is_optional": null } ], "outlier_params": [], "others": [] }

[ "MIT" ]

[ "Get", "the", "number", "of", "steps", "described", "in", "the", "dataframe", "Parameters", "df", ":", "pandas", ".", "DataFrame", "The", "dataframe", "containing", "`", "Step", "`", "column", "Returns", "n_steps", ":", "int", "The", "number", "of", "steps", "described", "in", "the", "dataframe" ]

[ "def", "_get_num_steps", "(", "df", ":", "pd", ".", "DataFrame", ")", "->", "int", ":", "if", "df", ".", "empty", ":", "raise", "ValueError", "(", "\"Empty dataframe\"", ")", "step", "=", "df", "[", "\"Step\"", "]", ".", "astype", "(", "int", ")", "return", "int", "(", "step", ".", "iloc", "[", "-", "1", "]", "-", "step", ".", "iloc", "[", "0", "]", ")" ]

[ "Get", "the", "number", "of", "steps", "described", "in", "the", "dataframe", "Parameters" ]

[ "\"\"\"\n Get the number of steps described in the dataframe\n\n Parameters\n ----------\n df : pandas.DataFrame\n The dataframe containing `Step` column\n\n Returns\n -------\n n_steps : int\n The number of steps described in the dataframe\n\n \"\"\"" ]

[ { "param": "df", "type": "pd.DataFrame" } ]

{ "returns": [], "raises": [], "params": [ { "identifier": "df", "type": "pd.DataFrame", "docstring": null, "docstring_tokens": [], "default": null, "is_optional": null } ], "outlier_params": [], "others": [] }

[ "BSD-3-Clause" ]

[ "Initializes", "the", "config", "from", "a", "string", ".", "The", "string", "is", "expected", "to", "contain", "the", "config", "as", "a", "variable", "named", "`", "`", "CONFIG", "`", "`", "." ]

[ "def", "from_string", "(", "cls", ",", "s", ",", "namespace", "=", "None", ")", ":", "if", "namespace", "is", "None", ":", "namespace", "=", "{", "}", "else", ":", "namespace", "=", "dict", "(", "namespace", ")", "exec", "(", "s", ",", "namespace", ")", "return", "cls", "(", "namespace", "[", "'CONFIG'", "]", ")" ]

[ "Initializes", "the", "config", "from", "a", "string", "." ]

[ "\"\"\"\n Initializes the config from a string. The string is expected to contain the config as a variable named ``CONFIG``.\n \"\"\"" ]

[ { "param": "cls", "type": null }, { "param": "s", "type": null }, { "param": "namespace", "type": null } ]

{ "returns": [], "raises": [], "params": [ { "identifier": "cls", "type": null, "docstring": null, "docstring_tokens": [], "default": null, "is_optional": null }, { "identifier": "s", "type": null, "docstring": null, "docstring_tokens": [], "default": null, "is_optional": null }, { "identifier": "namespace", "type": null, "docstring": null, "docstring_tokens": [], "default": null, "is_optional": null } ], "outlier_params": [], "others": [] }

[ "MIT" ]

[ "Function", "to", "get", "ratio", "of", "interesting", "characters", "in", "string", "Parameter", "dataset", "col_name", ":", "column", "name", "to", "get", "number", "of", "words", "Return", "df", ":", "dataset", "transformed" ]

[ "def", "ratio_capital_letters", "(", "df", ",", "col_name", ")", ":", "df", "[", "'{}_ratio_capital_letters'", ".", "format", "(", "col_name", ")", "]", "=", "df", "[", "col_name", "]", ".", "map", "(", "lambda", "x", ":", "len", "(", "[", "i", "for", "i", "in", "x", "if", "i", ".", "isupper", "(", ")", "]", ")", "/", "len", "(", "[", "i", "for", "i", "in", "x", "]", ")", "if", "isinstance", "(", "x", ",", "str", ")", "else", "0", ")", "return", "df" ]

[ "Function", "to", "get", "ratio", "of", "interesting", "characters", "in", "string", "Parameter" ]

[ "'''\n Function to get ratio of interesting characters in string\n\n Parameter\n ---------\n df: dataset\n col_name: column name to get number of words\n\n Return\n df: dataset transformed\n '''", "# print(df[[col_name, '{}_ratio_capital_letters'.format(col_name)]].head())" ]

[ { "param": "df", "type": null }, { "param": "col_name", "type": null } ]

{ "returns": [], "raises": [], "params": [ { "identifier": "df", "type": null, "docstring": null, "docstring_tokens": [], "default": null, "is_optional": null }, { "identifier": "col_name", "type": null, "docstring": null, "docstring_tokens": [], "default": null, "is_optional": null } ], "outlier_params": [], "others": [] }

[ "MIT" ]

[ "Calculated", "according", "to", "'", "Application", "of", "time", "series", "discretization", "using", "evolutionary", "programming", "for", "classification", "of", "precancerous", "cervical", "lesions", "'", "by", "H", ".", "Acosta", "-", "Mesa", "et", "al", ".", "2014" ]

[ "def", "calc_complexity", "(", "names_of_clusters", ")", ":", "single_words_length", "=", "len", "(", "list", "(", "set", "(", "names_of_clusters", ")", ")", ")", "len_timeseries", "=", "len", "(", "names_of_clusters", ")", "result", "=", "1", "-", "(", "single_words_length", "/", "len_timeseries", ")", "return", "result" ]

[ "Calculated", "according", "to", "'", "Application", "of", "time", "series", "discretization", "using", "evolutionary", "programming", "for", "classification", "of", "precancerous", "cervical", "lesions", "'", "by", "H", ".", "Acosta", "-", "Mesa", "et", "al", ".", "2014" ]

[ "\"\"\"\n Calculated according to 'Application of time series discretization using evolutionary programming for classification\n of precancerous cervical lesions' by H. Acosta-Mesa et al., 2014\n :param names_of_clusters: list containing a word which clusters the time series. e.g., ['abcffs', dddddd'...'svfdab']\n :return: level of complexity which penalizes the objective function\n \"\"\"", "# number of observations" ]

[ { "param": "names_of_clusters", "type": null } ]

{ "returns": [ { "docstring": "level of complexity which penalizes the objective function", "docstring_tokens": [ "level", "of", "complexity", "which", "penalizes", "the", "objective", "function" ], "type": null } ], "raises": [], "params": [ { "identifier": "names_of_clusters", "type": null, "docstring": "list containing a word which clusters the time series.", "docstring_tokens": [ "list", "containing", "a", "word", "which", "clusters", "the", "time", "series", "." ], "default": null, "is_optional": null } ], "outlier_params": [], "others": [] }

[ "Apache-2.0" ]

[ "Returns", "number", "of", "feed", "entries", "for", "category" ]

[ "def", "feed_size", "(", "category", ")", ":", "if", "category", ".", "key", ".", "id", "(", ")", "==", "'r0'", ":", "return", "100", "elif", "category", ".", "key", ".", "id", "(", ")", ".", "startswith", "(", "'c'", ")", ":", "return", "50", "return", "25" ]

[ "Returns", "number", "of", "feed", "entries", "for", "category" ]

[ "\"\"\"Returns number of feed entries for category\"\"\"", "# Root category", "# Level 2 category", "# category with subcategories" ]

[ { "param": "category", "type": null } ]

{ "returns": [], "raises": [], "params": [ { "identifier": "category", "type": null, "docstring": null, "docstring_tokens": [], "default": null, "is_optional": null } ], "outlier_params": [], "others": [] }

[ "MIT" ]

[ "Apply", "projective", "transformation", "(", "homography", ")", "on", "a", "point", "." ]

[ "def", "point_homography", "(", "point", ",", "H", ")", ":", "h0", ",", "h1", ",", "h2", "=", "H", "[", "0", "]", "h3", ",", "h4", ",", "h5", "=", "H", "[", "1", "]", "h6", ",", "h7", ",", "h8", "=", "H", "[", "2", "]", "x", ",", "y", "=", "point", "tx", "=", "h0", "*", "x", "+", "h1", "*", "y", "+", "h2", "ty", "=", "h3", "*", "x", "+", "h4", "*", "y", "+", "h5", "tz", "=", "h6", "*", "x", "+", "h7", "*", "y", "+", "h8", "homo", "=", "(", "tx", "/", "tz", ",", "ty", "/", "tz", ")", "return", "homo" ]

[ "Apply", "projective", "transformation", "(", "homography", ")", "on", "a", "point", "." ]

[ "\"\"\"Apply projective transformation (homography) on a point.\n\n Parameters:\n point: (x, y) tuple. \n A point for projective transformation.\n\n H: A homography matrix.\n \n Return:\n homo: (x, y) tuple.\n The point after projective transformation.\n \"\"\"" ]

[ { "param": "point", "type": null }, { "param": "H", "type": null } ]

{ "returns": [], "raises": [], "params": [ { "identifier": "point", "type": null, "docstring": "(x, y) tuple.\nA point for projective transformation.", "docstring_tokens": [ "(", "x", "y", ")", "tuple", ".", "A", "point", "for", "projective", "transformation", "." ], "default": null, "is_optional": null }, { "identifier": "H", "type": null, "docstring": "A homography matrix.", "docstring_tokens": [ "A", "homography", "matrix", "." ], "default": null, "is_optional": null } ], "outlier_params": [], "others": [] }

[ "Apache-2.0" ]

[ "Read", "the", "config", "file", ".", "If", "the", "option", "/", "section", "is", "not", "present", "return", "the", "default_option" ]

[ "def", "read_config_option", "(", "config", ",", "section", ",", "option", ",", "default_option", ")", ":", "if", "not", "config", ":", "return", "default_option", "try", ":", "val", "=", "config", ".", "get", "(", "section", ",", "option", ")", "except", "(", "configparser", ".", "NoOptionError", ",", "configparser", ".", "NoSectionError", ")", ":", "return", "default_option", "if", "val", ".", "lower", "(", ")", "==", "'true'", ":", "val", "=", "True", "elif", "val", ".", "lower", "(", ")", "==", "'false'", ":", "val", "=", "False", "elif", "not", "val", ":", "val", "=", "default_option", "if", "type", "(", "val", ")", "is", "not", "bool", "and", "val", "is", "not", "None", "and", "(", "'$__'", "in", "val", "or", "val", ".", "lower", "(", ")", "==", "'none'", ")", ":", "val", "=", "''", "if", "val", "==", "''", ":", "val", "=", "default_option", "return", "val" ]

[ "Read", "the", "config", "file", "." ]

[ "''' Read the config file. If the option/section is not present, return the default_option\n '''", "#elif val.lower() == 'false' or val.lower() == 'none':", "# ie. having a template value unpopulated(for $__xyz__)", "# or None" ]

[ { "param": "config", "type": null }, { "param": "section", "type": null }, { "param": "option", "type": null }, { "param": "default_option", "type": null } ]

{ "returns": [], "raises": [], "params": [ { "identifier": "config", "type": null, "docstring": null, "docstring_tokens": [], "default": null, "is_optional": null }, { "identifier": "section", "type": null, "docstring": null, "docstring_tokens": [], "default": null, "is_optional": null }, { "identifier": "option", "type": null, "docstring": null, "docstring_tokens": [], "default": null, "is_optional": null }, { "identifier": "default_option", "type": null, "docstring": null, "docstring_tokens": [], "default": null, "is_optional": null } ], "outlier_params": [], "others": [] }

[ "Apache-2.0" ]

[ "Returns", "path", "where", "the", "dataset", "is", "to", "be", "downloaded", "." ]

[ "def", "_kaggle_dir_name", "(", "competition_or_dataset", ":", "str", ")", "->", "str", ":", "return", "competition_or_dataset", ".", "replace", "(", "'/'", ",", "'_'", ")" ]

[ "Returns", "path", "where", "the", "dataset", "is", "to", "be", "downloaded", "." ]

[ "\"\"\"Returns path where the dataset is to be downloaded.\n\n Args:\n competition_or_dataset: Name of the kaggle competition/dataset.\n\n Returns:\n Path to the dir where the dataset is to be downloaded.\n \"\"\"" ]

[ { "param": "competition_or_dataset", "type": "str" } ]

{ "returns": [ { "docstring": "Path to the dir where the dataset is to be downloaded.", "docstring_tokens": [ "Path", "to", "the", "dir", "where", "the", "dataset", "is", "to", "be", "downloaded", "." ], "type": null } ], "raises": [], "params": [ { "identifier": "competition_or_dataset", "type": "str", "docstring": "Name of the kaggle competition/dataset.", "docstring_tokens": [ "Name", "of", "the", "kaggle", "competition", "/", "dataset", "." ], "default": null, "is_optional": null } ], "outlier_params": [], "others": [] }

[ "BSD-3-Clause" ]

[ "Display", "the", "data", "separated", "by", "the", "specified", "separator" ]

[ "def", "classicalOutput", "(", "queryResult", ",", "separator", "=", "\"\\t\"", ")", ":", "for", "line", "in", "queryResult", ":", "for", "element", "in", "line", ":", "sys", ".", "stdout", ".", "write", "(", "element", ")", "sys", ".", "stdout", ".", "write", "(", "separator", ")", "sys", ".", "stdout", ".", "write", "(", "'\\n'", ")" ]

[ "Display", "the", "data", "separated", "by", "the", "specified", "separator" ]

[ "\"\"\"\n Display the data separated by the specified separator\n \"\"\"" ]

[ { "param": "queryResult", "type": null }, { "param": "separator", "type": null } ]

{ "returns": [], "raises": [], "params": [ { "identifier": "queryResult", "type": null, "docstring": null, "docstring_tokens": [], "default": null, "is_optional": null }, { "identifier": "separator", "type": null, "docstring": null, "docstring_tokens": [], "default": null, "is_optional": null } ], "outlier_params": [], "others": [] }

[ "Apache-2.0" ]

[ "Return", "the", "key", "name", "from", "a", "file", "object", "." ]

[ "def", "_get_item_key", "(", "path", ":", "str", ")", ":", "try", ":", "key", "=", "os", ".", "getxattr", "(", "path", ",", "\"user.key\"", ")", "except", "OSError", ":", "if", "not", "os", ".", "path", ".", "exists", "(", "path", ")", ":", "raise", "FileNotFoundError", "(", "path", ")", "from", "None", "return", "os", ".", "path", ".", "basename", "(", "path", ")", "else", ":", "return", "key", ".", "decode", "(", ")" ]

[ "Return", "the", "key", "name", "from", "a", "file", "object", "." ]

[ "\"\"\"Return the key name from a file object.\n\n :returns: String\n \"\"\"" ]

[ { "param": "path", "type": "str" } ]

{ "returns": [ { "docstring": null, "docstring_tokens": [ "None" ], "type": null } ], "raises": [], "params": [ { "identifier": "path", "type": "str", "docstring": null, "docstring_tokens": [], "default": null, "is_optional": null } ], "outlier_params": [], "others": [] }

[ "MIT" ]

[ "Generate", "all", "strings", "that", "can", "be", "composed", "from", "the", "letters", "in", "word", "in", "any", "order", ".", "Returns", "a", "list", "of", "all", "strings", "that", "can", "be", "formed", "from", "the", "letters", "in", "word", ".", "This", "function", "should", "be", "recursive", "." ]

[ "def", "gen_all_strings", "(", "word", ")", ":", "if", "len", "(", "word", ")", "==", "0", ":", "return", "[", "\"\"", "]", "head", "=", "word", "[", "0", "]", "tail", "=", "word", "[", "1", ":", "]", "master_list", "=", "[", "]", "sub_list", "=", "gen_all_strings", "(", "tail", ")", "master_list", ".", "extend", "(", "sub_list", ")", "for", "sub_word", "in", "sub_list", ":", "for", "index", "in", "range", "(", "len", "(", "sub_word", ")", "+", "1", ")", ":", "master_list", ".", "append", "(", "sub_word", "[", ":", "index", "]", "+", "head", "+", "sub_word", "[", "index", ":", "]", ")", "return", "master_list" ]

[ "Generate", "all", "strings", "that", "can", "be", "composed", "from", "the", "letters", "in", "word", "in", "any", "order", "." ]

[ "\"\"\"\n Generate all strings that can be composed from the letters in word\n in any order.\n\n Returns a list of all strings that can be formed from the letters\n in word.\n\n This function should be recursive.\n \"\"\"", "# base case with no length word", "# recursive case", "# keep track of a master list while generating sub list", "# add sub list to master list", "# for each sub list word add to master list a combination of all", "# head character positions in sub word" ]

[ { "param": "word", "type": null } ]

{ "returns": [], "raises": [], "params": [ { "identifier": "word", "type": null, "docstring": null, "docstring_tokens": [], "default": null, "is_optional": null } ], "outlier_params": [], "others": [] }

[ "Apache-2.0" ]

[ "Chain", "strength", "that", "is", "scaled", "to", "the", "problem", "bias", "range", "." ]

[ "def", "scaled", "(", "bqm", ",", "embedding", "=", "None", ",", "prefactor", "=", "1.0", ")", ":", "if", "bqm", ".", "num_interactions", ">", "0", ":", "max_bias", "=", "max", "(", "max", "(", "bqm", ".", "linear", ".", "max", "(", ")", ",", "-", "bqm", ".", "linear", ".", "min", "(", ")", ")", ",", "max", "(", "bqm", ".", "quadratic", ".", "max", "(", ")", ",", "-", "bqm", ".", "quadratic", ".", "min", "(", ")", ")", ")", "return", "prefactor", "*", "max_bias", "else", ":", "return", "1" ]

[ "Chain", "strength", "that", "is", "scaled", "to", "the", "problem", "bias", "range", "." ]

[ "\"\"\"Chain strength that is scaled to the problem bias range.\n\n Args:\n bqm (:obj:`.BinaryQuadraticModel`):\n A binary quadratic model.\n\n embedding (dict/:class:`.EmbeddedStructure`, default=None):\n Included to satisfy the `chain_strength` callable specifications \n for `embed_bqm`. \n\n prefactor (float, optional, default=1.0):\n Prefactor used for scaling. \n\n Returns:\n float: The chain strength, or 1 if chain strength is not applicable.\n\n \"\"\"", "# won't matter (chain strength isn't needed to embed this problem)" ]

[ { "param": "bqm", "type": null }, { "param": "embedding", "type": null }, { "param": "prefactor", "type": null } ]

{ "returns": [ { "docstring": "The chain strength, or 1 if chain strength is not applicable.", "docstring_tokens": [ "The", "chain", "strength", "or", "1", "if", "chain", "strength", "is", "not", "applicable", "." ], "type": "float" } ], "raises": [], "params": [ { "identifier": "bqm", "type": null, "docstring": null, "docstring_tokens": [], "default": null, "is_optional": null }, { "identifier": "embedding", "type": null, "docstring": null, "docstring_tokens": [], "default": null, "is_optional": null }, { "identifier": "prefactor", "type": null, "docstring": "Prefactor used for scaling.", "docstring_tokens": [ "Prefactor", "used", "for", "scaling", "." ], "default": null, "is_optional": false } ], "outlier_params": [ { "identifier": "bqm (", "type": null, "docstring": "`.BinaryQuadraticModel`):\nA binary quadratic model.", "docstring_tokens": [ "`", ".", "BinaryQuadraticModel", "`", ")", ":", "A", "binary", "quadratic", "model", "." ], "default": null, "is_optional": null }, { "identifier": "embedding (dict/", "type": null, "docstring": "`.EmbeddedStructure`, default=None):\nIncluded to satisfy the `chain_strength` callable specifications\nfor `embed_bqm`.", "docstring_tokens": [ "`", ".", "EmbeddedStructure", "`", "default", "=", "None", ")", ":", "Included", "to", "satisfy", "the", "`", "chain_strength", "`", "callable", "specifications", "for", "`", "embed_bqm", "`", "." ], "default": null, "is_optional": null } ], "others": [] }

[ "Apache-2.0" ]

[ "Sort", "a", "series", "of", "packed", "list", "according", "to", "a", "ref", "list", ".", "Also", "return", "the", "original", "index", "before", "the", "sort", "." ]

[ "def", "sort", "(", "packed", ",", "ref", ",", "reverse", "=", "True", ")", ":", "assert", "(", "isinstance", "(", "packed", ",", "tuple", ")", "or", "isinstance", "(", "packed", ",", "list", ")", ")", "and", "isinstance", "(", "ref", ",", "list", ")", "packed", "=", "[", "ref", "]", "+", "[", "range", "(", "len", "(", "ref", ")", ")", "]", "+", "list", "(", "packed", ")", "sorted_packed", "=", "[", "list", "(", "t", ")", "for", "t", "in", "zip", "(", "*", "sorted", "(", "zip", "(", "*", "packed", ")", ",", "reverse", "=", "reverse", ")", ")", "]", "return", "tuple", "(", "sorted_packed", "[", "1", ":", "]", ")" ]

[ "Sort", "a", "series", "of", "packed", "list", "according", "to", "a", "ref", "list", "." ]

[ "\"\"\"\r\n Sort a series of packed list, according to a ref list.\r\n Also return the original index before the sort.\r\n \"\"\"" ]

[ { "param": "packed", "type": null }, { "param": "ref", "type": null }, { "param": "reverse", "type": null } ]

{ "returns": [], "raises": [], "params": [ { "identifier": "packed", "type": null, "docstring": null, "docstring_tokens": [], "default": null, "is_optional": null }, { "identifier": "ref", "type": null, "docstring": null, "docstring_tokens": [], "default": null, "is_optional": null }, { "identifier": "reverse", "type": null, "docstring": null, "docstring_tokens": [], "default": null, "is_optional": null } ], "outlier_params": [], "others": [] }

[ "MIT" ]

[ "Prints", "message", "with", "green", "color", "to", "show", "success" ]

[ "def", "print_verbose", "(", "error_message", ")", ":", "print", "(", "\"\\033[1;32mVERBOSE\\033[0m {}\"", ".", "format", "(", "error_message", ")", ")" ]

[ "Prints", "message", "with", "green", "color", "to", "show", "success" ]

[ "\"\"\"\n Prints message with green color to show success\n \"\"\"" ]

[ { "param": "error_message", "type": null } ]

{ "returns": [], "raises": [], "params": [ { "identifier": "error_message", "type": null, "docstring": null, "docstring_tokens": [], "default": null, "is_optional": null } ], "outlier_params": [], "others": [] }

[ "MIT" ]

[ "gets", "the", "number", "of", "lines", "from", "filename" ]

[ "def", "number_of_lines", "(", "filename", "=", "\"\"", ")", ":", "with", "open", "(", "filename", ",", "encoding", "=", "'utf-8'", ")", "as", "myFile", ":", "return", "sum", "(", "[", "1", "for", "line", "in", "myFile", "]", ")" ]

[ "gets", "the", "number", "of", "lines", "from", "filename" ]

[ "\"\"\"gets the number of lines from filename\n \"\"\"" ]

[ { "param": "filename", "type": null } ]

{ "returns": [], "raises": [], "params": [ { "identifier": "filename", "type": null, "docstring": null, "docstring_tokens": [], "default": null, "is_optional": null } ], "outlier_params": [], "others": [] }

[ "MIT" ]

[ "Ajoute", "le", "tuyau", "courant", "au", "circuit" ]

[ "def", "add", "(", "circuit", ",", "current", ")", ":", "for", "pipe", "in", "circuit", ":", "if", "pipe", ".", "rect", ".", "topleft", "==", "current", ".", "rect", ".", "topleft", ":", "circuit", ".", "remove", "(", "pipe", ")", "circuit", ".", "append", "(", "current", ")", "return", "circuit" ]

[ "Ajoute", "le", "tuyau", "courant", "au", "circuit" ]

[ "\"\"\"Ajoute le tuyau courant au circuit\"\"\"" ]

[ { "param": "circuit", "type": null }, { "param": "current", "type": null } ]

{ "returns": [], "raises": [], "params": [ { "identifier": "circuit", "type": null, "docstring": null, "docstring_tokens": [], "default": null, "is_optional": null }, { "identifier": "current", "type": null, "docstring": null, "docstring_tokens": [], "default": null, "is_optional": null } ], "outlier_params": [], "others": [] }

[ "MIT" ]

[ "Rotate", "a", "point", "counterclockwise", "by", "a", "given", "angle", "around", "a", "given", "origin", ".", "The", "angle", "should", "be", "given", "in", "radians", "." ]

[ "def", "rotate", "(", "point", ",", "angle", ")", ":", "ox", ",", "oy", "=", "0", ",", "0", "px", ",", "py", "=", "point", "qx", "=", "ox", "+", "math", ".", "cos", "(", "angle", ")", "*", "(", "px", "-", "ox", ")", "-", "math", ".", "sin", "(", "angle", ")", "*", "(", "py", "-", "oy", ")", "qy", "=", "oy", "+", "math", ".", "sin", "(", "angle", ")", "*", "(", "px", "-", "ox", ")", "+", "math", ".", "cos", "(", "angle", ")", "*", "(", "py", "-", "oy", ")", "return", "qx", ",", "qy" ]

[ "Rotate", "a", "point", "counterclockwise", "by", "a", "given", "angle", "around", "a", "given", "origin", "." ]

[ "\"\"\"\n Rotate a point counterclockwise by a given angle around a given origin.\n\n The angle should be given in radians.\n \"\"\"" ]

[ { "param": "point", "type": null }, { "param": "angle", "type": null } ]

{ "returns": [], "raises": [], "params": [ { "identifier": "point", "type": null, "docstring": null, "docstring_tokens": [], "default": null, "is_optional": null }, { "identifier": "angle", "type": null, "docstring": null, "docstring_tokens": [], "default": null, "is_optional": null } ], "outlier_params": [], "others": [] }

[ "Apache-2.0" ]

[ "Deletes", "an", "existing", "route", "asynchronously", "." ]

[ "def", "delete_route", "(", "compute", ",", "project", ",", "route", ")", ":", "route_deleted", "=", "compute", ".", "routes", "(", ")", ".", "delete", "(", "project", "=", "project", ",", "route", "=", "route", ")", ".", "execute", "(", ")", "return", "route_deleted" ]

[ "Deletes", "an", "existing", "route", "asynchronously", "." ]

[ "\"\"\" Deletes an existing route asynchronously.\"\"\"" ]

[ { "param": "compute", "type": null }, { "param": "project", "type": null }, { "param": "route", "type": null } ]

{ "returns": [], "raises": [], "params": [ { "identifier": "compute", "type": null, "docstring": null, "docstring_tokens": [], "default": null, "is_optional": null }, { "identifier": "project", "type": null, "docstring": null, "docstring_tokens": [], "default": null, "is_optional": null }, { "identifier": "route", "type": null, "docstring": null, "docstring_tokens": [], "default": null, "is_optional": null } ], "outlier_params": [], "others": [] }

[ "MIT" ]

[ "Create", "an", "absolute", "path", "from", "the", "file", "path", "and", "the", "path", "given", "in", "the", "config" ]

[ "def", "resolve_dir_name", "(", "config_filepath", ",", "dir_path", ")", ":", "if", "not", "os", ".", "path", ".", "isabs", "(", "dir_path", ")", ":", "config_path", "=", "os", ".", "path", ".", "abspath", "(", "os", ".", "path", ".", "dirname", "(", "config_filepath", ")", ")", "return", "os", ".", "path", ".", "join", "(", "config_path", ",", "dir_path", ")", "else", ":", "return", "dir_path" ]

[ "Create", "an", "absolute", "path", "from", "the", "file", "path", "and", "the", "path", "given", "in", "the", "config" ]

[ "\"\"\"Create an absolute path from the file path and the path given in the config\"\"\"" ]

[ { "param": "config_filepath", "type": null }, { "param": "dir_path", "type": null } ]

{ "returns": [], "raises": [], "params": [ { "identifier": "config_filepath", "type": null, "docstring": null, "docstring_tokens": [], "default": null, "is_optional": null }, { "identifier": "dir_path", "type": null, "docstring": null, "docstring_tokens": [], "default": null, "is_optional": null } ], "outlier_params": [], "others": [] }