Datasets:

euclaise

/

thevault-filtered

like 2

[ "BSD-3-Clause" ]

[ "Returns", "True", "if", "the", "interface", "'", "s", "member", "needs", "to", "be", "defined", "on", "the", "interface", "object", ".", "The", "following", "members", "must", "be", "defiend", "on", "an", "interface", "object", ".", "static", "members" ]

[ "def", "on_interface", "(", "interface", ",", "member", ")", ":", "if", "member", ".", "is_static", ":", "return", "True", "return", "False" ]

[ "Returns", "True", "if", "the", "interface", "'", "s", "member", "needs", "to", "be", "defined", "on", "the", "interface", "object", "." ]

[ "\"\"\"Returns True if the interface's member needs to be defined on the\n interface object.\n\n The following members must be defiend on an interface object.\n - static members\n \"\"\"" ]

[ { "param": "interface", "type": null }, { "param": "member", "type": null } ]

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

[ "MIT" ]

[ "There", "are", "two", "options", ":", "Either", "an", "index", "file", "path", "to", "get", "index", "information", "or", "an", "index", "name", "in", "which", "case", "prefix", "is", "a", "list", "with", "length", "1" ]

[ "def", "IndexFileOrInameToPrefixInfo", "(", "inp_d", ")", ":", "if", "\"index_name\"", "in", "inp_d", ":", "logging", ".", "info", "(", "\"Recognized index type as index name\"", ")", "prefix", "=", "[", "[", "0", ",", "\"\"", ",", "inp_d", "[", "'index_name'", "]", "]", "]", "prefixNames", "=", "[", "inp_d", "[", "'index_name'", "]", "]", "else", ":", "raise", "Exception", "(", "\"Program only works with index_names now,\"", "\" index file deprecated.\"", ")", "inp_d", "[", "'prefix'", "]", "=", "prefix", "inp_d", "[", "'prefixNames'", "]", "=", "prefixNames", "return", "inp_d" ]

[ "There", "are", "two", "options", ":", "Either", "an", "index", "file", "path", "to", "get", "index", "information", "or", "an", "index", "name", "in", "which", "case", "prefix", "is", "a", "list", "with", "length", "1" ]

[ "\"\"\"\n There are two options: Either an index file path to get index information,\n or an index name, in which case prefix is a list with length 1 \n Args:\n inp_d: (dict)\n [indexfile_fp] (str)\n\n OR\n\n index_name: (str)\n\n \"\"\"", "# Report String doesn't exist yet", "# nLeading (int), Some sequence (str), index_name (str)", "#updating inp_d" ]

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

{ "returns": [], "raises": [], "params": [ { "identifier": "inp_d", "type": null, "docstring": "(dict)\n[indexfile_fp] (str)\n\nOR\n\n(str)", "docstring_tokens": [ "(", "dict", ")", "[", "indexfile_fp", "]", "(", "str", ")", "OR", "(", "str", ")" ], "default": null, "is_optional": null } ], "outlier_params": [], "others": [] }

[ "MIT" ]

[ "Checks", "to", "see", "whether", "the", "string", "is", "empty", "." ]

[ "def", "string_is_empty", "(", "string", ":", "str", ")", ":", "is_empty", "=", "bool", "(", "len", "(", "string", ")", "<=", "0", ")", "return", "is_empty" ]

[ "Checks", "to", "see", "whether", "the", "string", "is", "empty", "." ]

[ "\"\"\"Checks to see whether the string is empty.\r\n\r\n Parameters\r\n ----------\r\n string : str\r\n The string that needs to be checked.\r\n\r\n Returns\r\n -------\r\n is_empty : str\r\n Checks the length of the string and\r\n Returns `True` if the string is empty, else `False`.\r\n \"\"\"" ]

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

{ "returns": [ { "docstring": "Checks the length of the string and\nReturns `True` if the string is empty, else `False`.", "docstring_tokens": [ "Checks", "the", "length", "of", "the", "string", "and", "Returns", "`", "True", "`", "if", "the", "string", "is", "empty", "else", "`", "False", "`", "." ], "type": "str\r" } ], "raises": [], "params": [ { "identifier": "string", "type": "str", "docstring": "The string that needs to be checked.", "docstring_tokens": [ "The", "string", "that", "needs", "to", "be", "checked", "." ], "default": null, "is_optional": false } ], "outlier_params": [], "others": [] }

[ "Apache-2.0" ]

[ "Creates", "callback", "to", "get", "demands", "at", "each", "location", "." ]

[ "def", "create_demand_evaluator", "(", "data", ")", ":", "_demands", "=", "data", "[", "'demands'", "]", "def", "demand_evaluator", "(", "manager", ",", "node", ")", ":", "\"\"\"Returns the demand of the current node\"\"\"", "return", "_demands", "[", "manager", ".", "IndexToNode", "(", "node", ")", "]", "return", "demand_evaluator" ]

[ "Creates", "callback", "to", "get", "demands", "at", "each", "location", "." ]

[ "\"\"\"Creates callback to get demands at each location.\"\"\"", "\"\"\"Returns the demand of the current node\"\"\"" ]

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

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

[ "MIT" ]

[ "Convert", "datetime", "into", "Modified", "Julian", "Date", "(", "float", ")", "This", "is", "a", "float", "data", "reference", "to", "2000", "-", "01", "-", "01T00", ":", "00", ":", "00", "which", "has", "a", "mjd", "of", "51544", "INPUT", ":", "datetime", "array", "OUTPUT", ":", "mjd", "array" ]

[ "def", "date2mjd", "(", "dates", ")", ":", "mjd", "=", "[", "(", "d", "-", "datetime", ".", "datetime", "(", "2000", ",", "1", ",", "1", ")", ")", ".", "days", "+", "(", "d", "-", "datetime", ".", "datetime", "(", "2000", ",", "1", ",", "1", ")", ")", ".", "seconds", "/", "86400.", "+", "51544", "for", "d", "in", "dates", "]", "return", "mjd" ]

[ "Convert", "datetime", "into", "Modified", "Julian", "Date", "(", "float", ")", "This", "is", "a", "float", "data", "reference", "to", "2000", "-", "01", "-", "01T00", ":", "00", ":", "00", "which", "has", "a", "mjd", "of", "51544", "INPUT", ":", "datetime", "array", "OUTPUT", ":", "mjd", "array" ]

[ "\"\"\"\n Convert datetime into Modified Julian Date (float)\n\n This is a float data reference to 2000-01-01T00:00:00 which has a mjd of 51544\n INPUT: datetime array\n OUTPUT: mjd array\n \"\"\"" ]

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

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

[ "MIT" ]

[ "For", "import", "data", "year", "2013", "from", "excel" ]

[ "def", "fetch_data_2013", "(", ")", ":", "static", "=", "open", "(", "\"airtraffic.csv\"", ",", "newline", "=", "\"\"", ")", "data", "=", "csv", ".", "reader", "(", "static", ")", "static", "=", "[", "run", "for", "run", "in", "data", "]", "static_2013", "=", "[", "]", "for", "run", "in", "static", ":", "if", "run", "[", "3", "]", "==", "\"2013\"", ":", "static_2013", ".", "append", "(", "run", ")", "return", "static_2013" ]

[ "For", "import", "data", "year", "2013", "from", "excel" ]

[ "\"\"\"For import data year 2013 from excel\"\"\"" ]

[]

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

[ "MIT" ]

[ "Returns", "True", "if", "testValue", "is", "an", "number", "and", "False", "otherwise", "." ]

[ "def", "is_number", "(", "testValue", ")", ":", "isNumber", "=", "True", "charactersDone", "=", "0", "currentCharacter", "=", "0", "positiveNegative", "=", "0", "decimal", "=", "0", "testValueString", "=", "str", "(", "testValue", ")", "testValueString", "=", "testValueString", ".", "strip", "(", ")", "totalCharacters", "=", "len", "(", "testValueString", ")", "if", "totalCharacters", "==", "0", ":", "isInteger", "=", "False", "while", "charactersDone", "<", "totalCharacters", ":", "if", "testValueString", "[", "currentCharacter", "]", "not", "in", "'-+0123456789. '", ":", "isNumber", "=", "False", "if", "testValueString", "[", "currentCharacter", "]", "in", "[", "' '", ",", "'-'", ",", "'+'", ",", "'.'", "]", "and", "totalCharacters", "==", "1", ":", "isNumber", "=", "False", "if", "testValueString", "[", "currentCharacter", "]", "in", "[", "'-'", ",", "'+'", "]", "and", "currentCharacter", "!=", "0", ":", "isNumber", "=", "False", "if", "testValueString", "[", "currentCharacter", "]", "in", "[", "'-'", ",", "'+'", "]", ":", "positiveNegative", "=", "positiveNegative", "+", "1", "if", "testValueString", "[", "currentCharacter", "]", "in", "[", "'.'", "]", ":", "decimal", "=", "decimal", "+", "1", "if", "positiveNegative", ">", "1", "or", "decimal", ">", "1", ":", "isNumber", "=", "False", "currentCharacter", "=", "currentCharacter", "+", "1", "charactersDone", "=", "charactersDone", "+", "1", "return", "isNumber" ]

[ "Returns", "True", "if", "testValue", "is", "an", "number", "and", "False", "otherwise", "." ]

[ "\"\"\"Returns True if testValue is an number and False otherwise.\"\"\"" ]

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

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

[ "MIT" ]

[ "Strips", "the", "suffix", "from", "a", "string", "if", "present", "." ]

[ "def", "strip_end", "(", "text", ":", "str", ",", "suffix", ":", "str", ",", "case_insensitive", ":", "bool", "=", "False", ")", "->", "str", ":", "if", "case_insensitive", ":", "if", "not", "text", ".", "lower", "(", ")", ".", "endswith", "(", "suffix", ".", "lower", "(", ")", ")", ":", "return", "text", "else", ":", "if", "not", "text", ".", "endswith", "(", "suffix", ")", ":", "return", "text", "return", "text", "[", ":", "len", "(", "text", ")", "-", "len", "(", "suffix", ")", "]" ]

[ "Strips", "the", "suffix", "from", "a", "string", "if", "present", "." ]

[ "\"\"\"Strips the suffix from a string if present.\n\n https://stackoverflow.com/a/1038999\n\n :param text: String to check for suffix\n :param suffix: Suffix to look for.\n :param case_insensitive: Do a case insensitive match. Defaults to False.\n :returns: The resulting string.\n \"\"\"" ]

[ { "param": "text", "type": "str" }, { "param": "suffix", "type": "str" }, { "param": "case_insensitive", "type": "bool" } ]

{ "returns": [ { "docstring": "The resulting string.", "docstring_tokens": [ "The", "resulting", "string", "." ], "type": null } ], "raises": [], "params": [ { "identifier": "text", "type": "str", "docstring": "String to check for suffix", "docstring_tokens": [ "String", "to", "check", "for", "suffix" ], "default": null, "is_optional": null }, { "identifier": "suffix", "type": "str", "docstring": "Suffix to look for.", "docstring_tokens": [ "Suffix", "to", "look", "for", "." ], "default": null, "is_optional": null }, { "identifier": "case_insensitive", "type": "bool", "docstring": "Do a case insensitive match. Defaults to False.", "docstring_tokens": [ "Do", "a", "case", "insensitive", "match", ".", "Defaults", "to", "False", "." ], "default": null, "is_optional": null } ], "outlier_params": [], "others": [] }

[ "Apache-2.0" ]

[ "Works", "with", "regexes", "with", "two", "matches", "where", "the", "text", "of", "the", "first", "match", "is", "replaced", "and", "the", "text", "of", "the", "second", "is", "returned" ]

[ "def", "extract_and_replace_one", "(", "text", ",", "pattern", ")", ":", "matches", "=", "pattern", ".", "findall", "(", "text", ")", "if", "matches", "and", "len", "(", "matches", ")", "==", "1", ":", "return", "text", ".", "replace", "(", "matches", "[", "0", "]", "[", "0", "]", ",", "''", ")", ",", "matches", "[", "0", "]", "[", "1", "]", "return", "text", ",", "None" ]

[ "Works", "with", "regexes", "with", "two", "matches", "where", "the", "text", "of", "the", "first", "match", "is", "replaced", "and", "the", "text", "of", "the", "second", "is", "returned" ]

[ "''' Works with regexes with two matches, where the text of the first match\n is replaced and the text of the second is returned\n\n In the case where there is a match:\n >>> text = 'I feelvery happy'\n >>> pattern = re.compile(r'.*(very\\s*(\\S*)).*')\n >>> modified_text, match = extract_and_replace_one(text, pattern)\n >>> print(modified_text)\n I feel\n >>> print(match)\n happy\n\n In the case where there is not a match:\n >>> text = 'I feel happy'\n >>> modified_text, match = extract_and_replace_one(text, pattern)\n >>> modified_text == text\n True\n >>> match is None\n True\n '''" ]

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

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

[ "0BSD" ]

[ "for", "the", "first", "and", "latest", "terminators", "we", "only", "need", "to", "check", "parent", "gene", "for", "one", "side", "of", "terminator", "and", "also", "need", "to", "take", "care", "of", "the", "terminal", "end" ]

[ "def", "first_term", "(", "strand", ",", "term", ",", "detect_terms", ",", "detect", ")", ":", "if", "(", "strand", "==", "\"+\"", ")", ":", "if", "(", "term", "[", "\"detect_p\"", "]", ")", ":", "detect_terms", "[", "\"detect\"", "]", ".", "append", "(", "term", ")", "detect", "=", "True", "else", ":", "detect_terms", "[", "\"undetect\"", "]", ".", "append", "(", "term", ")", "elif", "(", "strand", "==", "\"-\"", ")", ":", "if", "(", "term", "[", "\"detect_m\"", "]", ")", ":", "detect_terms", "[", "\"detect\"", "]", ".", "append", "(", "term", ")", "detect", "=", "True", "else", ":", "detect_terms", "[", "\"undetect\"", "]", ".", "append", "(", "term", ")", "return", "detect" ]

[ "for", "the", "first", "and", "latest", "terminators", "we", "only", "need", "to", "check", "parent", "gene", "for", "one", "side", "of", "terminator", "and", "also", "need", "to", "take", "care", "of", "the", "terminal", "end" ]

[ "'''for the first and latest terminators, \n we only need to check parent gene for one side of terminator\n and also need to take care of the terminal end'''" ]

[ { "param": "strand", "type": null }, { "param": "term", "type": null }, { "param": "detect_terms", "type": null }, { "param": "detect", "type": null } ]

{ "returns": [], "raises": [], "params": [ { "identifier": "strand", "type": null, "docstring": null, "docstring_tokens": [], "default": null, "is_optional": null }, { "identifier": "term", "type": null, "docstring": null, "docstring_tokens": [], "default": null, "is_optional": null }, { "identifier": "detect_terms", "type": null, "docstring": null, "docstring_tokens": [], "default": null, "is_optional": null }, { "identifier": "detect", "type": null, "docstring": null, "docstring_tokens": [], "default": null, "is_optional": null } ], "outlier_params": [], "others": [] }

[ "MIT" ]

[ "Calculates", "the", "relatives", "change", "in", "belief", "given", "a", "positive", "reading" ]

[ "def", "relative_change_bel_neg_reading", "(", "alpha", ",", "beta", ",", "prev_belief", ",", "prior_at_reading", ")", ":", "beta1", "=", "1", "-", "alpha", "-", "beta", "numerator", "=", "(", "(", "(", "1", "-", "alpha", ")", "*", "prev_belief", ")", "-", "(", "beta1", "*", "prior_at_reading", ")", ")", "denominator", "=", "(", "(", "(", "1", "-", "alpha", ")", "*", "prev_belief", ")", "-", "(", "beta1", "*", "prior_at_reading", "*", "prev_belief", ")", ")", "return", "numerator", "/", "denominator" ]

[ "Calculates", "the", "relatives", "change", "in", "belief", "given", "a", "positive", "reading" ]

[ "'''Calculates the relatives change in belief given a positive reading'''" ]

[ { "param": "alpha", "type": null }, { "param": "beta", "type": null }, { "param": "prev_belief", "type": null }, { "param": "prior_at_reading", "type": null } ]

{ "returns": [], "raises": [], "params": [ { "identifier": "alpha", "type": null, "docstring": null, "docstring_tokens": [], "default": null, "is_optional": null }, { "identifier": "beta", "type": null, "docstring": null, "docstring_tokens": [], "default": null, "is_optional": null }, { "identifier": "prev_belief", "type": null, "docstring": null, "docstring_tokens": [], "default": null, "is_optional": null }, { "identifier": "prior_at_reading", "type": null, "docstring": null, "docstring_tokens": [], "default": null, "is_optional": null } ], "outlier_params": [], "others": [] }

[ "MIT" ]

[ "Prepare", "simple", "list", "to", "inquirer", "list", ".", "Convert", "to", "dicts", "list", "with", "2", "keys", ":", "index", "and", "value", "from", "original", "list" ]

[ "def", "convert_to_list_with_index", "(", "items", ":", "list", ")", "->", "list", ":", "return", "[", "{", "'value'", ":", "index", ",", "'name'", ":", "item", "}", "for", "index", ",", "item", "in", "enumerate", "(", "items", ")", "]" ]

[ "Prepare", "simple", "list", "to", "inquirer", "list", "." ]

[ "\"\"\"\n Prepare simple list to inquirer list.\n Convert to dicts list, with 2 keys: index and value from original list\n\n Args:\n items (list): Original items list which needs to convert\n\n Return:\n list: List of dicts with index key and item\n \"\"\"" ]

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

{ "returns": [], "raises": [], "params": [ { "identifier": "items", "type": "list", "docstring": "Original items list which needs to convert", "docstring_tokens": [ "Original", "items", "list", "which", "needs", "to", "convert" ], "default": null, "is_optional": false } ], "outlier_params": [], "others": [] }

[ "BSD-3-Clause" ]

[ "Rewrites", "a", "path", "by", "prefixing", "it", "with", "the", "sysroot", "if", "it", "is", "absolute", "." ]

[ "def", "RewritePath", "(", "path", ",", "sysroot", ")", ":", "if", "os", ".", "path", ".", "isabs", "(", "path", ")", ":", "path", "=", "path", ".", "lstrip", "(", "'/'", ")", "return", "os", ".", "path", ".", "join", "(", "sysroot", ",", "path", ")", "else", ":", "return", "path" ]

[ "Rewrites", "a", "path", "by", "prefixing", "it", "with", "the", "sysroot", "if", "it", "is", "absolute", "." ]

[ "\"\"\"Rewrites a path by prefixing it with the sysroot if it is absolute.\"\"\"" ]

[ { "param": "path", "type": null }, { "param": "sysroot", "type": null } ]

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

[ "MIT" ]

[ "This", "code", "asumes", "the", "log_dir", "directory", "already", "exists" ]

[ "def", "write_metrics", "(", "log_dir", ",", "params", ")", ":", "metrics_file", "=", "os", ".", "path", ".", "join", "(", "log_dir", ",", "'metrics.json'", ")", "with", "open", "(", "metrics_file", ",", "'w'", ")", "as", "f", ":", "f", ".", "write", "(", "json", ".", "dumps", "(", "params", ")", ")" ]

[ "This", "code", "asumes", "the", "log_dir", "directory", "already", "exists" ]

[ "\"\"\"This code asumes the log_dir directory already exists\"\"\"" ]

[ { "param": "log_dir", "type": null }, { "param": "params", "type": null } ]

{ "returns": [], "raises": [], "params": [ { "identifier": "log_dir", "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": [] }

[ "BSD-3-Clause" ]

[ "Calls", "analysis_plugins", "after", "the", "installation", "has", "succeeded" ]

[ "def", "post_install_run", "(", "analysis_plugins", "=", "None", ",", "**", "kwargs", ")", "->", "None", ":", "if", "analysis_plugins", "is", "not", "None", ":", "for", "plugin", "in", "analysis_plugins", ":", "plugin", "(", ")", ".", "post_install_run", "(", "**", "kwargs", ")" ]

[ "Calls", "analysis_plugins", "after", "the", "installation", "has", "succeeded" ]

[ "\"\"\"\n Calls analysis_plugins after the installation has succeeded\n :param analysis_plugins: the plugins to call\n :param kwargs: keyword arguments to pass to plugins\n \"\"\"" ]

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

{ "returns": [], "raises": [], "params": [ { "identifier": "analysis_plugins", "type": null, "docstring": "the plugins to call", "docstring_tokens": [ "the", "plugins", "to", "call" ], "default": null, "is_optional": null } ], "outlier_params": [ { "identifier": "kwargs", "type": null, "docstring": "keyword arguments to pass to plugins", "docstring_tokens": [ "keyword", "arguments", "to", "pass", "to", "plugins" ], "default": null, "is_optional": null } ], "others": [] }

[ "MIT" ]

[ "Strip", "surrounding", "<", ">", "on", "an", "email", "address", "if", "present", "." ]

[ "def", "address_no_brackets", "(", "addr", ")", ":", "if", "addr", ".", "startswith", "(", "'<'", ")", "and", "addr", ".", "endswith", "(", "'>'", ")", ":", "return", "addr", "[", "1", ":", "-", "1", "]", "else", ":", "return", "addr" ]

[ "Strip", "surrounding", "<", ">", "on", "an", "email", "address", "if", "present", "." ]

[ "'''Strip surrounding <> on an email address, if present.'''" ]

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

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

[ "MIT" ]

[ "save", "the", "scrapped", "text", "to", "csv" ]

[ "def", "save_to_disk", "(", "text_corpus", ",", "entity", ")", ":", "with", "open", "(", "\"path\"", ",", "'a'", ")", "as", "file", ":", "for", "i", "in", "range", "(", "len", "(", "text_corpus", ")", ")", ":", "row", "=", "[", "i", ",", "entity", ",", "text_corpus", "[", "i", "]", "]", "writer", "=", "csv", ".", "writer", "(", "file", ")", "writer", ".", "writerow", "(", "row", ")", "file", ".", "close", "(", ")" ]

[ "save", "the", "scrapped", "text", "to", "csv" ]

[ "\"\"\"save the scrapped text to csv\n @params:\n \"\"\"" ]

[ { "param": "text_corpus", "type": null }, { "param": "entity", "type": null } ]

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

[ "BSD-3-Clause" ]

[ "Read", "the", "next", "item", "form", "an", "inp", "file" ]

[ "def", "inp_read_next_item", "(", "lines", ",", "pos", ")", ":", "token", "=", "lines", "[", "pos", "]", "pos", "=", "pos", "+", "1", "value", "=", "lines", "[", "pos", "]", "pos", "=", "pos", "+", "1", "return", "token", ",", "value", ",", "pos" ]

[ "Read", "the", "next", "item", "form", "an", "inp", "file" ]

[ "\"\"\"Read the next item form an inp file\"\"\"" ]

[ { "param": "lines", "type": null }, { "param": "pos", "type": null } ]

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

[ "MIT" ]

[ "Try", "to", "return", "a", "title", "and", "link", "for", "a", "direct", "link", "to", "an", "xkcd", "comic", "." ]

[ "def", "xkcd_direct", "(", "html", ",", "url", "=", "None", ")", ":", "if", "not", "html", ":", "return", "None", "if", "not", "url", ":", "url_match", "=", "re", ".", "search", "(", "r'Permanent link to this comic: ([^\\s<>]+)'", ",", "html", ")", "if", "url_match", ":", "url", "=", "url_match", ".", "group", "(", "1", ")", "else", ":", "return", "None", "match", "=", "re", ".", "search", "(", "r'<title>(.+?)</title>'", ",", "html", ")", "if", "match", ":", "return", "match", ".", "group", "(", "1", ")", "+", "\": \"", "+", "url", "else", ":", "return", "None" ]

[ "Try", "to", "return", "a", "title", "and", "link", "for", "a", "direct", "link", "to", "an", "xkcd", "comic", "." ]

[ "\"\"\"Try to return a title and link for a direct link to an xkcd comic.\"\"\"" ]

[ { "param": "html", "type": null }, { "param": "url", "type": null } ]

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

[ "MIT" ]

[ "Back", "iterator", ".", "Since", "we", "insert", "new", "text", "in", "the", "line", "string", "based", "on", "index", "we", "have", "to", "read", "from", "right", "to", "left", "in", "order", "to", "conserve", "the", "indexing", "." ]

[ "def", "backiter", "(", "iterable", ")", ":", "for", "m", "in", "[", "m", "for", "m", "in", "iterable", "]", "[", ":", ":", "-", "1", "]", ":", "yield", "m" ]

[ "Back", "iterator", "." ]

[ "'''\r\n\t\tBack iterator. Since we insert new text in the line string based on \r\n\t\tindex, we have to read from right to left in order to conserve the indexing.\r\n\t'''" ]

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

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

[ "MIT" ]

[ "Deterministically", "create", "a", "table", "with", "task", "/", "node", "/", "gpu", "allocations" ]

[ "def", "create_task_table", "(", "cls", ",", "num_ps", ",", "base_port", ",", "nodelist", ",", "tasklist", ",", "gpulist", ",", "my_node", ",", "my_proc", ")", ":", "tasktable", "=", "[", "]", "for", "node", ",", "num_tasks", "in", "zip", "(", "nodelist", ",", "tasklist", ")", ":", "gpu_alloc", "=", "[", "int", "(", "min", "(", "num_tasks", ",", "len", "(", "gpulist", ")", ")", "*", "task", "/", "num_tasks", ")", "for", "task", "in", "range", "(", "num_tasks", ")", "]", "for", "task", "in", "range", "(", "num_tasks", ")", ":", "tasktable", ".", "append", "(", "dict", "(", "node", "=", "node", ",", "node_task", "=", "task", ",", "role", "=", "cls", ".", "PARAMETER_SERVER", "if", "len", "(", "tasktable", ")", "<", "num_ps", "else", "cls", ".", "WORKER", ",", "global_task_index", "=", "len", "(", "tasktable", ")", ",", "role_index", "=", "len", "(", "tasktable", ")", "if", "len", "(", "tasktable", ")", "<", "num_ps", "else", "len", "(", "tasktable", ")", "-", "num_ps", ",", "port", "=", "base_port", "+", "task", ",", "gpu", "=", "gpulist", "[", "gpu_alloc", "[", "task", "]", "]", ",", "gpu_frac", "=", "1", "/", "sum", "(", "gpui", "==", "gpu_alloc", "[", "task", "]", "for", "gpui", "in", "gpu_alloc", ")", ",", "me", "=", "(", "node", "==", "my_node", "and", "len", "(", "tasktable", ")", "==", "int", "(", "my_proc", ")", ")", ")", ")", "return", "tasktable" ]

[ "Deterministically", "create", "a", "table", "with", "task", "/", "node", "/", "gpu", "allocations" ]

[ "'''\n Deterministically create a table with task/node/gpu allocations\n '''", "# Generate list of even gpu allocations over the current node", "# Create a config dictionary for each task on the node", "# Node the task is being run on", "# Local task index on node", "# Task type ", "# Global task index across all nodes", "# Task within role, e.g. ps:0,1,... or worker:0,1,2..", "# Port for parameter server communication", "# Allocated gpu for this task", "# Fraction of assigned gpu available to this task", "# Whether this task is the current process' task" ]

[ { "param": "cls", "type": null }, { "param": "num_ps", "type": null }, { "param": "base_port", "type": null }, { "param": "nodelist", "type": null }, { "param": "tasklist", "type": null }, { "param": "gpulist", "type": null }, { "param": "my_node", "type": null }, { "param": "my_proc", "type": null } ]

{ "returns": [], "raises": [], "params": [ { "identifier": "cls", "type": null, "docstring": null, "docstring_tokens": [], "default": null, "is_optional": null }, { "identifier": "num_ps", "type": null, "docstring": null, "docstring_tokens": [], "default": null, "is_optional": null }, { "identifier": "base_port", "type": null, "docstring": null, "docstring_tokens": [], "default": null, "is_optional": null }, { "identifier": "nodelist", "type": null, "docstring": null, "docstring_tokens": [], "default": null, "is_optional": null }, { "identifier": "tasklist", "type": null, "docstring": null, "docstring_tokens": [], "default": null, "is_optional": null }, { "identifier": "gpulist", "type": null, "docstring": null, "docstring_tokens": [], "default": null, "is_optional": null }, { "identifier": "my_node", "type": null, "docstring": null, "docstring_tokens": [], "default": null, "is_optional": null }, { "identifier": "my_proc", "type": null, "docstring": null, "docstring_tokens": [], "default": null, "is_optional": null } ], "outlier_params": [], "others": [] }

[ "MIT" ]

[ "Helper", "function", "to", "parse", "output", "from", "get_info", "get_status", "and", "get_setup", "." ]

[ "def", "_multiline_output_to_dict", "(", "lines", ":", "List", "[", "bytes", "]", ")", ":", "return", "collections", ".", "defaultdict", "(", "str", ",", "[", "(", "k", ".", "strip", "(", ")", ",", "v", ".", "strip", "(", ")", ")", "for", "k", ",", "_", ",", "v", "in", "[", "line", ".", "decode", "(", ")", ".", "partition", "(", "\"=\"", ")", "for", "line", "in", "lines", "]", "]", ",", ")" ]

[ "Helper", "function", "to", "parse", "output", "from", "get_info", "get_status", "and", "get_setup", "." ]

[ "\"\"\"Helper function to parse output from get_info, get_status and get_setup.\"\"\"" ]

[ { "param": "lines", "type": "List[bytes]" } ]

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

[ "Apache-2.0" ]

[ "Parse", "element", "text", "as", "float", "Parameters", ":", "elem", ":", "the", "element", "path", ":", "the", "element", "path", "Return", "float", "value", "if", "parsable", "otherwise", "None" ]

[ "def", "parseFloat", "(", "elem", ",", "path", ")", ":", "text", "=", "elem", ".", "findtext", "(", "path", ")", "if", "text", "!=", "None", ":", "return", "float", "(", "text", ")", "else", ":", "return", "None" ]

[ "Parse", "element", "text", "as", "float", "Parameters", ":", "elem", ":", "the", "element", "path", ":", "the", "element", "path" ]

[ "\"\"\"\n Parse element text as float\n Parameters:\n - elem : the element\n - path : the element path \n \n Return float value if parsable, otherwise None\n \"\"\"" ]

[ { "param": "elem", "type": null }, { "param": "path", "type": null } ]

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

[ "MIT" ]

[ "Convert", "a", "batch", "of", "size", "1", "to", "a", "single", "observation", "." ]

[ "def", "_batch_to_observation", "(", "batch", ",", "obs_shape", ")", ":", "if", "batch", ".", "shape", "!=", "obs_shape", ":", "assert", "batch", ".", "shape", "==", "(", "1", ",", "*", "obs_shape", ")", ",", "f'batch.shape={repr(batch.shape)} does not correspond to obs_shape={repr(obs_shape)} with batch dimension added'", "return", "batch", ".", "reshape", "(", "obs_shape", ")", "return", "batch" ]

[ "Convert", "a", "batch", "of", "size", "1", "to", "a", "single", "observation", "." ]

[ "\"\"\"\n Convert a batch of size 1, to a single observation.\n \"\"\"" ]

[ { "param": "batch", "type": null }, { "param": "obs_shape", "type": null } ]

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

[ "MIT" ]

[ "Helps", "the", "make_child", "function", "inside", "the", "Tetris", "Class", "create", "a", "child", "genome", "using", "a", "weighted", "average", "between", "the", "fitnesses", "of", "the", "two", "parents", ".", "Adds", "a", "little", "randomness", "to", "avoid", "a", "value", "equaling", "zero" ]

[ "def", "_make_child", "(", "parent1", ",", "parent2", ",", "factor", ")", ":", "fitness1", "=", "parent1", "[", "'fitness'", "]", "fitness2", "=", "parent2", "[", "'fitness'", "]", "factor1", "=", "parent1", "[", "factor", "]", "factor2", "=", "parent2", "[", "factor", "]", "normalizingFitness", "=", "fitness1", "+", "fitness2", "newFitness", "=", "(", "fitness1", "*", "factor1", "+", "fitness2", "*", "factor2", ")", "/", "normalizingFitness", "return", "newFitness" ]

[ "Helps", "the", "make_child", "function", "inside", "the", "Tetris", "Class", "create", "a", "child", "genome", "using", "a", "weighted", "average", "between", "the", "fitnesses", "of", "the", "two", "parents", "." ]

[ "'''Helps the make_child function inside the Tetris Class create a child\r\n genome using a weighted average between the fitnesses of the two parents.\r\n Adds a little randomness to avoid a value equaling zero\r\n \r\n Arguments:\r\n parent1: a parent genome dict, usually a random one from the genome\r\n parent2: a parent genome dict, usually an elite genome\r\n factor: a string representing the feature that will be computed\r\n \r\n Return Value:\r\n An integer value representing the numeric value of the genome\r\n '''" ]

[ { "param": "parent1", "type": null }, { "param": "parent2", "type": null }, { "param": "factor", "type": null } ]

{ "returns": [], "raises": [], "params": [ { "identifier": "parent1", "type": null, "docstring": "a parent genome dict, usually a random one from the genome", "docstring_tokens": [ "a", "parent", "genome", "dict", "usually", "a", "random", "one", "from", "the", "genome" ], "default": null, "is_optional": null }, { "identifier": "parent2", "type": null, "docstring": "a parent genome dict, usually an elite genome", "docstring_tokens": [ "a", "parent", "genome", "dict", "usually", "an", "elite", "genome" ], "default": null, "is_optional": null }, { "identifier": "factor", "type": null, "docstring": "a string representing the feature that will be computed", "docstring_tokens": [ "a", "string", "representing", "the", "feature", "that", "will", "be", "computed" ], "default": null, "is_optional": null } ], "outlier_params": [], "others": [] }

[ "MIT" ]

[ "Computes", "reciprocal", "of", "square", "root", "of", "x", "element", "-", "wise", "." ]

[ "def", "rsqrt", "(", "x", ":", "Tensor", ")", ":", "return", "x", ".", "rsqrt", "(", ")" ]

[ "Computes", "reciprocal", "of", "square", "root", "of", "x", "element", "-", "wise", "." ]

[ "\"\"\"Computes reciprocal of square root of x element-wise.\n\n Args:\n x: input tensor\n\n Returns:\n output tensor\n\n\n Examples:\n >>> x = to_tensor([2., 0., -2.])\n >>> rsqrt(x)\n <Tensor: shape=(3,), dtype=float32,\n numpy=array([0.707, inf, nan], dtype=float32)>\n\n \"\"\"" ]

[ { "param": "x", "type": "Tensor" } ]

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

[ "MIT" ]

[ "Recursively", "generate", "all", "valid", "combinations", "of", "hidden", "layers", ".", "Parameters", ".", "List", "of", "int", ".", "List", "all", "possible", "neuron", "numbers", "for", "a", "single", "hidden", "layer", ".", "List", "of", "int", ".", "Recursive", "return", ".", "Return", "the", "updated", "combination", "during", "recursion", "process", ".", "combination_list_total", ":", "Multi", "-", "dimentional", "list", "of", "int", ".", "Store", "all", "possible", "combinations", "recursively", "generated", "by", "the", "function", "." ]

[ "def", "combinationRecursion", "(", "neuron_num_options_list", ",", "layer_num", ",", "combination_list_temp", ",", "combination_list_total", ")", ":", "for", "item", "in", "neuron_num_options_list", ":", "combination_list_temp", ".", "append", "(", "item", ")", "if", "len", "(", "combination_list_temp", ")", ">=", "layer_num", ":", "combination_list_total", ".", "append", "(", "copy", ".", "deepcopy", "(", "combination_list_temp", ")", ")", "combination_list_temp", "=", "copy", ".", "deepcopy", "(", "combination_list_temp", "[", ":", "-", "1", "]", ")", "else", ":", "combination_list_temp", ",", "combination_list_total", "=", "combinationRecursion", "(", "neuron_num_options_list", ",", "layer_num", ",", "combination_list_temp", ",", "combination_list_total", ")", "combination_list_temp", "=", "copy", ".", "deepcopy", "(", "combination_list_temp", "[", ":", "-", "1", "]", ")", "return", "combination_list_temp", ",", "combination_list_total" ]

[ "Recursively", "generate", "all", "valid", "combinations", "of", "hidden", "layers", "." ]

[ "\"\"\"\r\n Recursively generate all valid combinations of hidden layers. \r\n\r\n Parameters:\r\n ----------\r\n neuron_num_options_list: List of int. \r\n List all possible neuron numbers for a single hidden layer. \r\n layer_num: Int. \r\n The number of intended hidden layers. \r\n combination_list_temp: List of int. \r\n A single combination of a hidden layer. Appendable. \r\n combination_list_total: Multi-dimentional list of int. \r\n Store all possible combinations recursively generated by the function.\r\n\r\n Returns:\r\n ----------\r\n combination_list_temp: List of int. \r\n Recursive return. \r\n Return the updated combination during recursion process. \r\n combination_list_total: Multi-dimentional list of int. \r\n Store all possible combinations recursively generated by the function.\r\n \"\"\"" ]

[ { "param": "neuron_num_options_list", "type": null }, { "param": "layer_num", "type": null }, { "param": "combination_list_temp", "type": null }, { "param": "combination_list_total", "type": null } ]

{ "returns": [], "raises": [], "params": [ { "identifier": "neuron_num_options_list", "type": null, "docstring": null, "docstring_tokens": [], "default": null, "is_optional": null }, { "identifier": "layer_num", "type": null, "docstring": null, "docstring_tokens": [], "default": null, "is_optional": null }, { "identifier": "combination_list_temp", "type": null, "docstring": null, "docstring_tokens": [], "default": null, "is_optional": null }, { "identifier": "combination_list_total", "type": null, "docstring": null, "docstring_tokens": [], "default": null, "is_optional": null } ], "outlier_params": [], "others": [] }

[ "Apache-2.0" ]

[ "Populates", "split2samples", "with", "splits", "by", "region", "and", "country", "done", "on", "top", "of", "core", "splits", "." ]

[ "def", "_set_location_splits", "(", "split2samples", ":", "DefaultDict", "[", "str", ",", "List", "[", "Sample", "]", "]", ",", "db", ":", "NuPlanDB", ",", "core_splits_names", ":", "List", "[", "str", "]", ")", "->", "None", ":", "for", "split_name", "in", "core_splits_names", ":", "region_accumulator", "=", "[", "]", "for", "region", "in", "db", ".", "regions", ":", "region_split_name", "=", "split_name", "+", "'.'", "+", "region", "country_split_name", "=", "split_name", "+", "'.'", "+", "db", ".", "country", "(", "region", ")", "split2samples", "[", "region_split_name", "]", "=", "[", "rec", "for", "rec", "in", "split2samples", "[", "split_name", "]", "if", "rec", ".", "extraction", ".", "log", ".", "location", "in", "db", ".", "locations", "(", "region", ")", "]", "if", "country_split_name", "not", "in", "split2samples", ":", "split2samples", "[", "country_split_name", "]", "=", "[", "]", "split2samples", "[", "country_split_name", "]", "+=", "split2samples", "[", "region_split_name", "]", "region_accumulator", "+=", "split2samples", "[", "region_split_name", "]", "assert", "set", "(", "region_accumulator", ")", "==", "set", "(", "split2samples", "[", "split_name", "]", ")" ]

[ "Populates", "split2samples", "with", "splits", "by", "region", "and", "country", "done", "on", "top", "of", "core", "splits", "." ]

[ "\"\"\"\n Populates split2samples with splits by region and country done on top of core splits.\n\n For example:\n \"train\" -> \"train\", \"train.United_States\", \"train.bs\", , \"train.lv\", \"train.ptc\", \"train.Singapore\", \"train.sg\".\n\n :param split2samples: Main dictionary containing a mapping from split name to its corresponding data. The data is\n given as a list of samples. This function assumes core splits already exists (e.g. \"train\", \"val, \"test\").\n :param db: NuPlanDB.\n :param core_splits_names: Split names on which the location splits should be done. (e.g. \"train\", \"val, \"test\").\n \"\"\"", "# Assert that regions covered all samples." ]

[ { "param": "split2samples", "type": "DefaultDict[str, List[Sample]]" }, { "param": "db", "type": "NuPlanDB" }, { "param": "core_splits_names", "type": "List[str]" } ]

{ "returns": [], "raises": [], "params": [ { "identifier": "split2samples", "type": "DefaultDict[str, List[Sample]]", "docstring": "Main dictionary containing a mapping from split name to its corresponding data. The data is\ngiven as a list of samples. This function assumes core splits already exists .", "docstring_tokens": [ "Main", "dictionary", "containing", "a", "mapping", "from", "split", "name", "to", "its", "corresponding", "data", ".", "The", "data", "is", "given", "as", "a", "list", "of", "samples", ".", "This", "function", "assumes", "core", "splits", "already", "exists", "." ], "default": null, "is_optional": null }, { "identifier": "db", "type": "NuPlanDB", "docstring": null, "docstring_tokens": [ "None" ], "default": null, "is_optional": null }, { "identifier": "core_splits_names", "type": "List[str]", "docstring": "Split names on which the location splits should be done.", "docstring_tokens": [ "Split", "names", "on", "which", "the", "location", "splits", "should", "be", "done", "." ], "default": null, "is_optional": null } ], "outlier_params": [], "others": [] }

[ "MIT" ]

[ "Convert", "Tweet", "'", "s", "and", "TwitterAccount", "'", "s", "fields", "storing", "ID", "values", "to", "fit", "UnsignedBigIntegerField", "." ]

[ "def", "forwards_func", "(", "apps", ",", "schema_editor", ")", ":", "Tweet", "=", "apps", ".", "get_model", "(", "'twitter'", ",", "'Tweet'", ")", "TwitterAccount", "=", "apps", ".", "get_model", "(", "'twitter'", ",", "'TwitterAccount'", ")", "db_alias", "=", "schema_editor", ".", "connection", ".", "alias", "for", "tweet", "in", "Tweet", ".", "objects", ".", "using", "(", "db_alias", ")", ".", "all", "(", ")", ":", "tweet", ".", "tweet_id", "=", "int", "(", "tweet", ".", "tweet_id", ")", "-", "2", "**", "63", "tweet", ".", "save", "(", ")", "for", "account", "in", "TwitterAccount", ".", "objects", ".", "using", "(", "db_alias", ")", ".", "all", "(", ")", ":", "account", ".", "account_id", "=", "int", "(", "account", ".", "account_id", ")", "-", "2", "**", "63", "if", "account", ".", "last_known_tweet_id", "==", "''", ":", "account", ".", "last_known_tweet_id", "=", "0", "-", "2", "**", "63", "else", ":", "account", ".", "last_known_tweet_id", "=", "int", "(", "account", ".", "last_known_tweet_id", ")", "-", "2", "**", "63", "account", ".", "save", "(", ")" ]

[ "Convert", "Tweet", "'", "s", "and", "TwitterAccount", "'", "s", "fields", "storing", "ID", "values", "to", "fit", "UnsignedBigIntegerField", "." ]

[ "\"\"\"\n Convert Tweet's and TwitterAccount's fields storing ID values to fit UnsignedBigIntegerField.\n\n This applies to Tweet's tweet_id and TwitterAccount's account_id and last_known_tweet_id.\n Do so by substracting 2^63 to have full 64-bit value range.\n \"\"\"" ]

[ { "param": "apps", "type": null }, { "param": "schema_editor", "type": null } ]

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

[ "BSD-2-Clause" ]

[ "Disables", "output", "to", "the", "device", ".", "Attaches", "the", "kernel", "driver", "if", "available", "." ]

[ "def", "disable", "(", "dev", ")", ":", "if", "dev", ".", "is_kernel_driver_active", "(", "0", ")", ":", "return", "ret", "=", "dev", ".", "ctrl_transfer", "(", "0x40", ",", "0x0b", ",", "0x0000", ",", "0x01", ",", "None", ",", "500", ")", "if", "ret", "<", "0", ":", "raise", "RuntimeError", "(", "\"relayctl: failure to disable bitbang mode\"", ")", "try", ":", "dev", ".", "attach_kernel_driver", "(", "0", ")", "except", ":", "print", "(", "\"relayctl: could not attach kernel driver\"", ")" ]

[ "Disables", "output", "to", "the", "device", "." ]

[ "\"\"\"\n\tDisables output to the device.\n\tAttaches the kernel driver if available.\n\n\t@param dev: device\n\t\"\"\"", "# Disable bitbang mode" ]

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

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

[ "MIT" ]

[ "The", "relation", "between", "the", "color1", "and", "color2", "in", "RED", "stars", "assuming", "that", "the", "RED", "stars", "are", "2", "times", "brighter", "in", "color2", "flux", "in", "color2", "Returns", "flux", "in", "color1" ]

[ "def", "red_star", "(", "c2", ")", ":", "c1", "=", "0.5", "*", "c2", "return", "c1", ",", "c2" ]

[ "The", "relation", "between", "the", "color1", "and", "color2", "in", "RED", "stars", "assuming", "that", "the", "RED", "stars", "are", "2", "times", "brighter", "in", "color2" ]

[ "\"\"\"\n The relation between the color1 and color2 in RED stars\n assuming that the RED stars are 2 times brighter in color2\n ----------\n c2: flux in color2\n ----------\n Returns\n - flux in color1\n \"\"\"" ]

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

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

[ "Apache-2.0" ]

[ ":", "returns", "sum", "of", "positive", "numbers" ]

[ "def", "sum_positive_numbers", "(", "n", ")", ":", "if", "n", "==", "0", ":", "return", "0", "else", ":", "return", "n", "+", "sum_positive_numbers", "(", "n", "-", "1", ")" ]

[ ":", "returns", "sum", "of", "positive", "numbers" ]

[ "\"\"\"\n :returns sum of positive numbers\n \"\"\"" ]

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

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

[ "Apache-2.0" ]

[ "Checks", "that", "a", "possible", "UUID4", "string", "is", "a", "valid", "UUID4", "." ]

[ "def", "valid_uuid", "(", "possible_uuid", ")", ":", "regex", "=", "re", ".", "compile", "(", "'^[a-f0-9]{8}-?[a-f0-9]{4}-?4[a-f0-9]{3}-?[89ab][a-f0-9]{3}-?[a-f0-9]{12}\\Z'", ",", "re", ".", "I", ")", "match", "=", "regex", ".", "match", "(", "possible_uuid", ")", "return", "bool", "(", "match", ")" ]

[ "Checks", "that", "a", "possible", "UUID4", "string", "is", "a", "valid", "UUID4", "." ]

[ "\"\"\"\n Checks that a possible UUID4 string is a valid UUID4.\n \"\"\"" ]

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

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

[ "MIT" ]

[ "Internal", "method", "to", "process", "returned", "vision", "repsonse", ".", "Splits", "the", "response", "into", "a", "list", "of", "lists", "where", "each", "inner", "list", "is", "the", "length", "of", "specified", "column_length", "." ]

[ "def", "__process_vision", "(", "response", ",", "column_length", ")", ":", "vision", "=", "list", "(", ")", "current", "=", "list", "(", ")", "for", "j", "in", "range", "(", "1", ",", "len", "(", "response", ")", ")", ":", "if", "(", "j", "-", "1", ")", "%", "column_length", "==", "0", ":", "if", "len", "(", "current", ")", ">", "0", ":", "vision", ".", "append", "(", "current", ")", "current", "=", "list", "(", ")", "current", ".", "append", "(", "response", "[", "j", "]", ")", "vision", ".", "append", "(", "current", ")", "return", "vision" ]

[ "Internal", "method", "to", "process", "returned", "vision", "repsonse", "." ]

[ "\"\"\"\n Internal method to process returned vision repsonse. Splits the response into a list of\n lists where each inner list is the length of specified column_length.\n :param response:\n :param column_length:\n :return:\n \"\"\"" ]

[ { "param": "response", "type": null }, { "param": "column_length", "type": null } ]

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

[ "Apache-2.0" ]

[ "Raises", "an", "exception", "in", "the", "threads", "with", "id", "tid", "@", "In", "tid", "integer", "this", "variable", "represents", "the", "id", "of", "the", "thread", "to", "raise", "an", "exception", "@", "In", "exceptionType", "Exception", "the", "type", "of", "exception", "to", "throw", "@", "Out", "None" ]

[ "def", "_asyncRaise", "(", "tid", ",", "exceptionType", ")", ":", "if", "not", "inspect", ".", "isclass", "(", "exceptionType", ")", ":", "raise", "TypeError", "(", "\"Only types can be raised (not instances)\"", ")", "res", "=", "ctypes", ".", "pythonapi", ".", "PyThreadState_SetAsyncExc", "(", "tid", ",", "ctypes", ".", "py_object", "(", "exceptionType", ")", ")", "if", "res", "==", "0", ":", "raise", "ValueError", "(", "\"invalid thread id\"", ")", "elif", "res", "!=", "1", ":", "ctypes", ".", "pythonapi", ".", "PyThreadState_SetAsyncExc", "(", "tid", ",", "0", ")", "raise", "SystemError", "(", "\"PyThreadState_SetAsyncExc failed\"", ")" ]

[ "Raises", "an", "exception", "in", "the", "threads", "with", "id", "tid", "@", "In", "tid", "integer", "this", "variable", "represents", "the", "id", "of", "the", "thread", "to", "raise", "an", "exception", "@", "In", "exceptionType", "Exception", "the", "type", "of", "exception", "to", "throw", "@", "Out", "None" ]

[ "\"\"\"\n Raises an exception in the threads with id tid\n @ In, tid, integer, this variable represents the id of the thread to raise an exception\n @ In, exceptionType, Exception, the type of exception to throw\n @ Out, None\n \"\"\"", "# \"if it returns a number greater than one, you're in trouble,", "# and you should call it again with exc=NULL to revert the effect\"" ]

[ { "param": "tid", "type": null }, { "param": "exceptionType", "type": null } ]

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

[ "Apache-2.0" ]

[ "Perform", "combining", "rule", "to", "get", "A", "+", "A", "sigma", "parameter", ".", "Output", "units", "are", "whatever", "those", "are", "of", "the", "input", "parameters", "." ]

[ "def", "sigma", "(", "ab_sig", ",", "bb_sig", ")", ":", "if", "ab_sig", "is", "not", "None", "and", "bb_sig", "is", "not", "None", ":", "aa_sig", "=", "2.0", "*", "ab_sig", "-", "bb_sig", "else", ":", "aa_sig", "=", "None", "return", "aa_sig" ]

[ "Perform", "combining", "rule", "to", "get", "A", "+", "A", "sigma", "parameter", "." ]

[ "\"\"\" Perform combining rule to get A+A sigma parameter.\n Output units are whatever those are of the input parameters.\n\n :param ab_sig: A+B sigma parameter\n :type ab_sig: float\n :param ab_sig: B+B sigma parameter\n :type ab_sig: float\n :rtype: float\n \"\"\"" ]

[ { "param": "ab_sig", "type": null }, { "param": "bb_sig", "type": null } ]

{ "returns": [ { "docstring": null, "docstring_tokens": [ "None" ], "type": "float" } ], "raises": [], "params": [ { "identifier": "ab_sig", "type": null, "docstring": "B+B sigma parameter", "docstring_tokens": [ "B", "+", "B", "sigma", "parameter" ], "default": null, "is_optional": null }, { "identifier": "bb_sig", "type": null, "docstring": null, "docstring_tokens": [], "default": null, "is_optional": null } ], "outlier_params": [], "others": [] }

[ "BSD-3-Clause" ]

[ "Wrap", "text", "in", "my", "in", "-", "HTML", "footnote", "style" ]

[ "def", "cmd_footnote", "(", "ensoapi", ")", ":", "seldict", "=", "ensoapi", ".", "get_selection", "(", ")", "text", "=", "seldict", ".", "get", "(", "\"text\"", ",", "\"\"", ")", "html", "=", "seldict", ".", "get", "(", "\"html\"", ",", "text", ")", "if", "not", "text", ":", "ensoapi", ".", "display_message", "(", "\"No selection!\"", ")", "else", ":", "result", "=", "'<span style=\"color:red\" title=\"%s\">*</span>'", "%", "html", "ensoapi", ".", "set_selection", "(", "{", "\"text\"", ":", "result", "}", ")" ]

[ "Wrap", "text", "in", "my", "in", "-", "HTML", "footnote", "style" ]

[ "\"Wrap text in my in-HTML footnote style\"" ]

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

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

[ "MIT" ]

[ "Return", "true", "if", "x", "is", "in", "the", "range", "[", "start", "end", "]" ]

[ "def", "time_in_range", "(", "start_hour", ",", "end_hour", ")", ":", "start", "=", "datetime", ".", "time", "(", "(", "start_hour", ")", ",", "0", ",", "0", ")", "end", "=", "datetime", ".", "time", "(", "(", "end_hour", ")", ",", "0", ",", "0", ")", "current_hour", "=", "datetime", ".", "datetime", ".", "now", "(", ")", ".", "strftime", "(", "'%H'", ")", "current_min", "=", "datetime", ".", "datetime", ".", "now", "(", ")", ".", "strftime", "(", "'%M'", ")", "current_sec", "=", "datetime", ".", "datetime", ".", "now", "(", ")", ".", "strftime", "(", "'%S'", ")", "x", "=", "datetime", ".", "time", "(", "int", "(", "current_hour", ")", ",", "int", "(", "current_min", ")", ",", "int", "(", "current_sec", ")", ")", "if", "start", "<=", "end", ":", "return", "start", "<=", "x", "<=", "end", "else", ":", "return", "start", "<=", "x", "or", "x", "<=", "end" ]

[ "Return", "true", "if", "x", "is", "in", "the", "range", "[", "start", "end", "]" ]

[ "\"\"\"Return true if x is in the range [start, end]\"\"\"" ]

[ { "param": "start_hour", "type": null }, { "param": "end_hour", "type": null } ]

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

[ "Apache-2.0" ]

[ "Makes", "sure", "that", "the", "coordinate", "length", "is", "at", "least", "4", "to", "include", "group", "artifact", "type", "and", "version", "name" ]

[ "def", "_check_coordinate_length", "(", "line", ")", ":", "if", "len", "(", "line", ".", "split", "(", "\":\"", ")", ")", "<", "4", ":", "return", "False", "else", ":", "return", "True" ]

[ "Makes", "sure", "that", "the", "coordinate", "length", "is", "at", "least", "4", "to", "include", "group", "artifact", "type", "and", "version", "name" ]

[ "'''\n Makes sure that the coordinate length is at least 4 to\n include group, artifact, type, and version name\n '''" ]

[ { "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" ]

[ "Decorator", "to", "add", "logging", "information", "around", "calls", "for", "use", "with", "." ]

[ "def", "logfunction", "(", "func", ")", ":", "def", "_wrapper", "(", "*", "args", ",", "**", "kwds", ")", ":", "logging", ".", "info", "(", "\"Start::%s:%s\"", ",", "func", ".", "__module__", ",", "func", ".", "__name__", ")", "returnval", "=", "func", "(", "*", "args", ",", "**", "kwds", ")", "logging", ".", "info", "(", "\"Finish::%s:%s\"", ",", "func", ".", "__module__", ",", "func", ".", "__name__", ")", "return", "returnval", "return", "_wrapper" ]

[ "Decorator", "to", "add", "logging", "information", "around", "calls", "for", "use", "with", "." ]

[ "\"\"\" Decorator to add logging information around calls for use with . \"\"\"" ]

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

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

[ "Apache-2.0" ]

[ "Removes", "columns", "of", "data", "frame", "where", "any", "value", "is", "NaN", "." ]

[ "def", "remove_nan_columns", "(", "dataframe", ")", ":", "df_copy", "=", "dataframe", ".", "set_index", "(", "\"timestamp\"", ")", "selected_columns_mask", "=", "df_copy", ".", "notnull", "(", ")", ".", "all", "(", ")", ".", "values", "return", "dataframe", ".", "dropna", "(", "axis", "=", "1", ",", "how", "=", "\"any\"", ")", ",", "selected_columns_mask" ]

[ "Removes", "columns", "of", "data", "frame", "where", "any", "value", "is", "NaN", "." ]

[ "\"\"\"Removes columns of data frame where any value is NaN.\n\n Args:\n dataframe (pandas.DataFrame): Input dataframe.\n\n Returns:\n tuple: tuple containing:\n pandas.DataFrame: Dataframe with columns containing NaN values removed.\n numpy.array: Array of bools indicating which columns were kept.\n \"\"\"" ]

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

{ "returns": [ { "docstring": "tuple containing:\npandas.DataFrame: Dataframe with columns containing NaN values removed.\nnumpy.array: Array of bools indicating which columns were kept.", "docstring_tokens": [ "tuple", "containing", ":", "pandas", ".", "DataFrame", ":", "Dataframe", "with", "columns", "containing", "NaN", "values", "removed", ".", "numpy", ".", "array", ":", "Array", "of", "bools", "indicating", "which", "columns", "were", "kept", "." ], "type": "tuple" } ], "raises": [], "params": [ { "identifier": "dataframe", "type": null, "docstring": null, "docstring_tokens": [ "None" ], "default": null, "is_optional": false } ], "outlier_params": [], "others": [] }

[ "Apache-2.0" ]

[ "Store", "all", "edges", "for", "each", "relation", "." ]

[ "def", "store_edges", "(", "quads", ")", ":", "edges", "=", "dict", "(", ")", "relations", "=", "list", "(", "set", "(", "quads", "[", ":", ",", "1", "]", ")", ")", "for", "rel", "in", "relations", ":", "edges", "[", "rel", "]", "=", "quads", "[", "quads", "[", ":", ",", "1", "]", "==", "rel", "]", "return", "edges" ]

[ "Store", "all", "edges", "for", "each", "relation", "." ]

[ "\"\"\"\n Store all edges for each relation.\n\n Parameters:\n quads (np.ndarray): indices of quadruples\n\n Returns:\n edges (dict): edges for each relation\n \"\"\"" ]

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

{ "returns": [ { "docstring": "edges (dict): edges for each relation", "docstring_tokens": [ "edges", "(", "dict", ")", ":", "edges", "for", "each", "relation" ], "type": null } ], "raises": [], "params": [ { "identifier": "quads", "type": null, "docstring": "indices of quadruples", "docstring_tokens": [ "indices", "of", "quadruples" ], "default": null, "is_optional": false } ], "outlier_params": [], "others": [] }

[ "MIT" ]

[ "Chunk", "an", "iterator", "into", "blocks", "of", "fixed", "size", ".", "Only", "the", "last", "block", "can", "be", "smaller", "than", "the", "specified", "size", "." ]

[ "def", "chunks", "(", "iterator", ",", "size", ")", ":", "items", "=", "[", "None", "]", "*", "size", "count", "=", "0", "for", "item", "in", "iterator", ":", "items", "[", "count", "]", "=", "item", "count", "+=", "1", "if", "count", "==", "size", ":", "yield", "items", "count", "=", "0", "yield", "items", "[", ":", "count", "]" ]

[ "Chunk", "an", "iterator", "into", "blocks", "of", "fixed", "size", "." ]

[ "\"\"\"\n Chunk an iterator into blocks of fixed size. Only the last block can be\n smaller than the specified size.\n\n :param iterator iterator: Iterator to exhaust.\n :param int size: Size of blocks to yield.\n \"\"\"", "# Yield remaining" ]

[ { "param": "iterator", "type": null }, { "param": "size", "type": null } ]

{ "returns": [], "raises": [], "params": [ { "identifier": "iterator", "type": null, "docstring": "Iterator to exhaust.", "docstring_tokens": [ "Iterator", "to", "exhaust", "." ], "default": null, "is_optional": false }, { "identifier": "size", "type": null, "docstring": "Size of blocks to yield.", "docstring_tokens": [ "Size", "of", "blocks", "to", "yield", "." ], "default": null, "is_optional": false } ], "outlier_params": [], "others": [] }

[ "MIT" ]

[ "A", "'", "compensatoric", "'", "operator", "combining", "AND", "with", "OR", "by", "a", "weighing", "factor", "l", ".", "This", "complicates", "matters", "a", "little", "since", "all", "combinators", "promise", "to", "just", "take", "2", "functions", "as", "arguments", "so", "we", "parametrize", "this", "with", "l", "." ]

[ "def", "lambda_op", "(", "l", ")", ":", "assert", "(", "0", "<=", "l", "<=", "1", ")", "def", "e", "(", "a", ",", "b", ")", ":", "def", "f", "(", "z", ")", ":", "x", ",", "y", "=", "a", "(", "z", ")", ",", "b", "(", "z", ")", "return", "l", "*", "(", "x", "*", "y", ")", "+", "(", "1", "-", "l", ")", "*", "(", "x", "+", "y", "-", "x", "*", "y", ")", "return", "f", "return", "e" ]

[ "A", "'", "compensatoric", "'", "operator", "combining", "AND", "with", "OR", "by", "a", "weighing", "factor", "l", ".", "This", "complicates", "matters", "a", "little", "since", "all", "combinators", "promise", "to", "just", "take", "2", "functions", "as", "arguments", "so", "we", "parametrize", "this", "with", "l", "." ]

[ "\"\"\"A 'compensatoric' operator, combining AND with OR by a weighing factor l.\n \n This complicates matters a little, since all combinators promise to just take \n 2 functions as arguments, so we parametrize this with l.\n \"\"\"", "# TODO: Expand.." ]

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

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

[ "MIT" ]

[ "Call", "in", "a", "loop", "to", "create", "terminal", "progress", "bar" ]

[ "def", "_print_progress", "(", "iteration", ",", "total", ",", "prefix", "=", "''", ",", "suffix", "=", "''", ",", "decimals", "=", "1", ",", "bar_length", "=", "10", ")", ":", "str_format", "=", "\"{0:.\"", "+", "str", "(", "decimals", ")", "+", "\"f}\"", "percents", "=", "str_format", ".", "format", "(", "100", "*", "(", "iteration", "/", "float", "(", "total", ")", ")", ")", "filled_length", "=", "int", "(", "round", "(", "bar_length", "*", "iteration", "/", "float", "(", "total", ")", ")", ")", "bar", "=", "'#'", "*", "filled_length", "+", "'-'", "*", "(", "bar_length", "-", "filled_length", ")", "sys", ".", "stdout", ".", "write", "(", "'\\r%s |%s| %s%s %s'", "%", "(", "prefix", ",", "bar", ",", "percents", ",", "'%'", ",", "suffix", ")", ")", ",", "if", "iteration", "==", "total", ":", "sys", ".", "stdout", ".", "write", "(", "'\\n'", ")", "sys", ".", "stdout", ".", "flush", "(", ")" ]

[ "Call", "in", "a", "loop", "to", "create", "terminal", "progress", "bar" ]

[ "\"\"\"\n Call in a loop to create terminal progress bar\n @params:\n iteration - Required : current iteration (Int)\n total - Required : total iterations (Int)\n prefix - Optional : prefix string (Str)\n suffix - Optional : suffix string (Str)\n decimals - Optional : positive number of decimals in percent complete (Int)\n bar_length - Optional : character length of bar (Int)\n \"\"\"" ]

[ { "param": "iteration", "type": null }, { "param": "total", "type": null }, { "param": "prefix", "type": null }, { "param": "suffix", "type": null }, { "param": "decimals", "type": null }, { "param": "bar_length", "type": null } ]

{ "returns": [], "raises": [], "params": [ { "identifier": "iteration", "type": null, "docstring": null, "docstring_tokens": [], "default": null, "is_optional": null }, { "identifier": "total", "type": null, "docstring": null, "docstring_tokens": [], "default": null, "is_optional": null }, { "identifier": "prefix", "type": null, "docstring": null, "docstring_tokens": [], "default": null, "is_optional": null }, { "identifier": "suffix", "type": null, "docstring": null, "docstring_tokens": [], "default": null, "is_optional": null }, { "identifier": "decimals", "type": null, "docstring": null, "docstring_tokens": [], "default": null, "is_optional": null }, { "identifier": "bar_length", "type": null, "docstring": null, "docstring_tokens": [], "default": null, "is_optional": null } ], "outlier_params": [], "others": [ { "identifier": "params", "docstring": "iteration - Required : current iteration (Int)\ntotal - Required : total iterations (Int)\nprefix - Optional : prefix string (Str)\nsuffix - Optional : suffix string (Str)\ndecimals - Optional : positive number of decimals in percent complete (Int)\nbar_length - Optional : character length of bar (Int)", "docstring_tokens": [ "iteration", "-", "Required", ":", "current", "iteration", "(", "Int", ")", "total", "-", "Required", ":", "total", "iterations", "(", "Int", ")", "prefix", "-", "Optional", ":", "prefix", "string", "(", "Str", ")", "suffix", "-", "Optional", ":", "suffix", "string", "(", "Str", ")", "decimals", "-", "Optional", ":", "positive", "number", "of", "decimals", "in", "percent", "complete", "(", "Int", ")", "bar_length", "-", "Optional", ":", "character", "length", "of", "bar", "(", "Int", ")" ] } ] }

[ "BSD-3-Clause" ]

[ "Match", "token", "offsets", "with", "the", "char", "begin", "/", "end", "offsets", "of", "the", "answer", "." ]

[ "def", "find_answer", "(", "offsets", ",", "begin_offset", ",", "end_offset", ")", ":", "start", "=", "[", "i", "for", "i", ",", "tok", "in", "enumerate", "(", "offsets", ")", "if", "tok", "[", "0", "]", "==", "begin_offset", "]", "end", "=", "[", "i", "for", "i", ",", "tok", "in", "enumerate", "(", "offsets", ")", "if", "tok", "[", "1", "]", "==", "end_offset", "]", "assert", "(", "len", "(", "start", ")", "<=", "1", ")", "assert", "(", "len", "(", "end", ")", "<=", "1", ")", "if", "len", "(", "start", ")", "==", "1", "and", "len", "(", "end", ")", "==", "1", ":", "return", "start", "[", "0", "]", ",", "end", "[", "0", "]" ]

[ "Match", "token", "offsets", "with", "the", "char", "begin", "/", "end", "offsets", "of", "the", "answer", "." ]

[ "\"\"\"Match token offsets with the char begin/end offsets of the answer.\"\"\"" ]

[ { "param": "offsets", "type": null }, { "param": "begin_offset", "type": null }, { "param": "end_offset", "type": null } ]

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

[ "MIT" ]

[ "Attempt", "to", "update", "the", "index", "analysis", "settings", "." ]

[ "def", "_update_index_analysis", "(", "conn", ",", "name", ",", "analysis", ")", ":", "settings", "=", "conn", ".", "indices", ".", "get_settings", "(", "index", "=", "name", ")", "existing", "=", "settings", "[", "name", "]", "[", "'settings'", "]", "[", "'index'", "]", ".", "get", "(", "'analysis'", ",", "{", "}", ")", "if", "existing", "!=", "analysis", ":", "try", ":", "conn", ".", "indices", ".", "close", "(", "index", "=", "name", ")", "conn", ".", "indices", ".", "put_settings", "(", "index", "=", "name", ",", "body", "=", "{", "'analysis'", ":", "analysis", "}", ")", "finally", ":", "conn", ".", "indices", ".", "open", "(", "index", "=", "name", ")" ]

[ "Attempt", "to", "update", "the", "index", "analysis", "settings", "." ]

[ "\"\"\"Attempt to update the index analysis settings.\"\"\"" ]

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

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

[ "MIT" ]

[ "Creates", "database", "from", "whole", "content", "which", "was", "collected", "and", "reformatted", "as", "dataframe", "." ]

[ "def", "create_db_from_data_frame", "(", "db_path", ",", "summary_df", ")", ":", "conn", "=", "sqlite3", ".", "connect", "(", "db_path", ")", "summary_df", ".", "to_sql", "(", "\"genes\"", ",", "conn", ",", "if_exists", "=", "\"replace\"", ")" ]

[ "Creates", "database", "from", "whole", "content", "which", "was", "collected", "and", "reformatted", "as", "dataframe", "." ]

[ "\"\"\"\n Creates database from whole content which was collected and reformatted as dataframe.\n\n :param db_path: full path of future database\n :param summary_df: content for future database\n \"\"\"" ]

[ { "param": "db_path", "type": null }, { "param": "summary_df", "type": null } ]

{ "returns": [], "raises": [], "params": [ { "identifier": "db_path", "type": null, "docstring": "full path of future database", "docstring_tokens": [ "full", "path", "of", "future", "database" ], "default": null, "is_optional": null }, { "identifier": "summary_df", "type": null, "docstring": "content for future database", "docstring_tokens": [ "content", "for", "future", "database" ], "default": null, "is_optional": null } ], "outlier_params": [], "others": [] }

[ "MIT" ]

[ "Launches", "an", "application", "capturing", "output", ".", "This", "wraps", "subprocess", ".", "Popen", "to", "provide", "some", "common", "parameters", "and", "to", "pass", "environment", "variables", "that", "may", "be", "needed", "by", "rbssh", "if", "indirectly", "invoked", "." ]

[ "def", "popen", "(", "cls", ",", "command", ",", "local_site_name", "=", "None", ")", ":", "env", "=", "os", ".", "environ", ".", "copy", "(", ")", "if", "local_site_name", ":", "env", "[", "b'RB_LOCAL_SITE'", "]", "=", "local_site_name", ".", "encode", "(", "'utf-8'", ")", "env", "[", "b'PYTHONPATH'", "]", "=", "(", "':'", ".", "join", "(", "sys", ".", "path", ")", ")", ".", "encode", "(", "'utf-8'", ")", "return", "subprocess", ".", "Popen", "(", "command", ",", "env", "=", "env", ",", "stderr", "=", "subprocess", ".", "PIPE", ",", "stdout", "=", "subprocess", ".", "PIPE", ",", "close_fds", "=", "(", "os", ".", "name", "!=", "'nt'", ")", ")" ]

[ "Launches", "an", "application", "capturing", "output", "." ]

[ "\"\"\"Launches an application, capturing output.\n\n This wraps subprocess.Popen to provide some common parameters and\n to pass environment variables that may be needed by rbssh, if\n indirectly invoked.\n \"\"\"" ]

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

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

[ "MIT" ]

[ "Uses", "a", "greedy", "heuristic", "to", "determine", "an", "allocation", "of", "cows", "that", "attempts", "to", "minimize", "the", "number", "of", "spaceship", "trips", "needed", "to", "transport", "all", "the", "cows", ".", "The", "returned", "allocation", "of", "cows", "may", "or", "may", "not", "be", "optimal", ".", "The", "greedy", "heuristic", "should", "follow", "the", "following", "method", ".", "1", ".", "As", "long", "as", "the", "current", "trip", "can", "fit", "another", "cow", "add", "the", "largest", "cow", "that", "will", "fit", "to", "the", "trip", "2", ".", "Once", "the", "trip", "is", "full", "begin", "a", "new", "trip", "to", "transport", "the", "remaining", "cows", "Does", "not", "mutate", "the", "given", "dictionary", "of", "cows", ".", "a", "dictionary", "of", "name", "(", "string", ")", "weight", "(", "int", ")", "pairs", "limit", "-", "weight", "limit", "of", "the", "spaceship", "(", "an", "int", ")", "A", "list", "of", "lists", "with", "each", "inner", "list", "containing", "the", "names", "of", "cows", "transported", "on", "a", "particular", "trip", "and", "the", "overall", "list", "containing", "all", "the", "trips" ]

[ "def", "greedy_cow_transport", "(", "cows", ",", "limit", "=", "10", ")", ":", "trip", "=", "[", "]", "trips", "=", "[", "]", "trip_weight", "=", "0", "heaviest_cows", "=", "sorted", "(", "cows", ".", "items", "(", ")", ",", "key", "=", "lambda", "x", ":", "x", "[", "1", "]", ",", "reverse", "=", "True", ")", "heaviest_cows", "=", "[", "name", "for", "(", "name", ",", "weight", ")", "in", "heaviest_cows", "]", "while", "heaviest_cows", ":", "for", "name", "in", "heaviest_cows", "[", ":", "]", ":", "weight", "=", "cows", "[", "name", "]", "if", "weight", "+", "trip_weight", "<=", "limit", ":", "try", ":", "heaviest_cows", ".", "index", "(", "name", ")", "except", ":", "pass", "else", ":", "trip", ".", "append", "(", "name", ")", "trip_weight", "+=", "weight", "heaviest_cows", ".", "remove", "(", "name", ")", "elif", "weight", ">", "limit", ":", "heaviest_cows", ".", "remove", "(", "name", ")", "trips", ".", "append", "(", "trip", ")", "trip", "=", "[", "]", "trip_weight", "=", "0", "return", "trips" ]

[ "Uses", "a", "greedy", "heuristic", "to", "determine", "an", "allocation", "of", "cows", "that", "attempts", "to", "minimize", "the", "number", "of", "spaceship", "trips", "needed", "to", "transport", "all", "the", "cows", "." ]

[ "\"\"\"\r\n Uses a greedy heuristic to determine an allocation of cows that attempts to\r\n minimize the number of spaceship trips needed to transport all the cows. The\r\n returned allocation of cows may or may not be optimal.\r\n The greedy heuristic should follow the following method:\r\n\r\n 1. As long as the current trip can fit another cow, add the largest cow that will fit\r\n to the trip\r\n 2. Once the trip is full, begin a new trip to transport the remaining cows\r\n\r\n Does not mutate the given dictionary of cows.\r\n\r\n Parameters:\r\n cows - a dictionary of name (string), weight (int) pairs\r\n limit - weight limit of the spaceship (an int)\r\n \r\n Returns:\r\n A list of lists, with each inner list containing the names of cows\r\n transported on a particular trip and the overall list containing all the\r\n trips\r\n \"\"\"", "# refer: def __getitem__(self, key): return self.data[key]\r", "# heaviest_cows = sorted(cows, key=cows.__getitem__, reverse=True)\r", "# To prevent unexpected result caused by the altered list,\r", "# use copy of the list\r", "# Checks still here (the cow is not loaded yet);\r", "# Already gone, just skip;\r", "# Still here, load the cow\r" ]

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

{ "returns": [], "raises": [], "params": [ { "identifier": "cows", "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": [] }

[ "Unlicense" ]

[ "Searching", "in", "a", "list", "takes", "linear", "time", "O", "(", "n", ")" ]

[ "def", "example_nine", "(", ")", ":", "x", "=", "list", "(", "range", "(", "10", "**", "6", ")", ")", "i", "=", "x", ".", "index", "(", "991234", ")" ]

[ "Searching", "in", "a", "list", "takes", "linear", "time", "O", "(", "n", ")" ]

[ "\"\"\"\n Searching in a list takes linear time O(n)\n \"\"\"" ]

[]

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

[ "Apache-2.0", "CC0-1.0", "MIT", "BSL-1.0", "BSD-3-Clause" ]

[ "Return", "true", "iff", "argument", "is", "a", "scoped", "node", "." ]

[ "def", "isScopeNode", "(", "pyAstNode", ")", ":", "if", "isinstance", "(", "pyAstNode", ",", "(", "ast", ".", "Module", ",", "ast", ".", "ClassDef", ",", "ast", ".", "FunctionDef", ",", "ast", ".", "Lambda", ",", "ast", ".", "GeneratorExp", ")", ")", ":", "return", "True", "else", ":", "return", "False" ]

[ "Return", "true", "iff", "argument", "is", "a", "scoped", "node", "." ]

[ "\"\"\"Return true iff argument is a scoped node.\"\"\"" ]

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

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

[ "Apache-2.0" ]

[ "Convert", "the", "request", "payload", "from", "bytes", "for", "a", "given", "request", "'", "s", "Content", "Type", "header" ]

[ "def", "convert_request_payload", "(", "request", ")", ":", "if", "'application/json'", "in", "request", ".", "headers", "[", "'Content-Type'", "]", ".", "values", ":", "return", "json", ".", "loads", "(", "request", ".", "payload", ")", "elif", "'application/octet-stream'", "in", "request", ".", "headers", "[", "'Content-Type'", "]", ".", "values", ":", "return", "request", ".", "payload", "elif", "'text/plain'", "in", "request", ".", "headers", "[", "'Content-Type'", "]", ".", "values", ":", "return", "request", ".", "payload", ".", "decode", "(", "'UTF-8'", ")", "return", "request", ".", "payload" ]

[ "Convert", "the", "request", "payload", "from", "bytes", "for", "a", "given", "request", "'", "s", "Content", "Type", "header" ]

[ "\"\"\"\n Convert the request payload from bytes for a given request's Content Type header\n :param request: the request Message\n :return: varies by content type header, e.g., dict or str\n \"\"\"" ]

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

{ "returns": [ { "docstring": "varies by content type header, e.g., dict or str", "docstring_tokens": [ "varies", "by", "content", "type", "header", "e", ".", "g", ".", "dict", "or", "str" ], "type": null } ], "raises": [], "params": [ { "identifier": "request", "type": null, "docstring": "the request Message", "docstring_tokens": [ "the", "request", "Message" ], "default": null, "is_optional": null } ], "outlier_params": [], "others": [] }

[ "MIT" ]

[ "return", "a", "list", "of", "names", "of", "tests", "found", "in", "." ]

[ "def", "importQC", "(", "dir", ")", ":", "testFiles", "=", "glob", ".", "glob", "(", "dir", "+", "'/[!_]*.py'", ")", "testNames", "=", "[", "testFile", "[", "len", "(", "dir", ")", "+", "1", ":", "-", "3", "]", "for", "testFile", "in", "testFiles", "]", "return", "testNames" ]

[ "return", "a", "list", "of", "names", "of", "tests", "found", "in", "<dir", ">", ":" ]

[ "'''\n return a list of names of tests found in <dir>:\n '''" ]

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

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

[ "MIT" ]

[ "Check", "the", "length", "of", "the", "values", "to", "recode" ]

[ "def", "_check_length", "(", "val", ",", "x", ",", "name", ")", ":", "length_x", "=", "len", "(", "val", ")", "n", "=", "len", "(", "x", ")", "if", "length_x", "in", "(", "1", ",", "n", ")", ":", "return", "if", "n", "==", "1", ":", "raise", "ValueError", "(", "f\"{name} must be length 1, not {length_x}.\"", ")", "raise", "ValueError", "(", "f\"{name} must be length {n}, not {length_x}.\"", ")" ]

[ "Check", "the", "length", "of", "the", "values", "to", "recode" ]

[ "\"\"\"Check the length of the values to recode\"\"\"" ]

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

{ "returns": [], "raises": [], "params": [ { "identifier": "val", "type": null, "docstring": null, "docstring_tokens": [], "default": null, "is_optional": null }, { "identifier": "x", "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" ]

[ "Post", "-", "processing", "function", ";", "adjust", "it", "with", "your", "custom", "pp", "functions", "." ]

[ "def", "postprocessing", "(", "input_img", ",", "PP", ",", "opt", "=", "None", ")", ":", "logging", ".", "basicConfig", "(", "level", "=", "logging", ".", "INFO", ",", "format", "=", "'%(levelname)s: %(message)s'", ")", "if", "'+'", "not", "in", "PP", ":", "PP", "=", "[", "PP", "]", "else", ":", "PP", "=", "PP", ".", "split", "(", "'+'", ")", "output", "=", "input_img", "for", "pp", "in", "PP", ":", "if", "pp", "==", "\"denoise\"", ":", "logging", ".", "info", "(", "'denoising...'", ")", "elif", "pp", "==", "\"chrom-adapt\"", ":", "logging", ".", "info", "(", "'chrom adapting...'", ")", "elif", "pp", "==", "\"deblur\"", ":", "logging", ".", "info", "(", "'deblurring...'", ")", "elif", "pp", "==", "\"dehaze\"", ":", "logging", ".", "info", "(", "'dehazing...'", ")", "elif", "pp", "==", "\"editdetails\"", ":", "logging", ".", "info", "(", "'editing local details...'", ")", "elif", "pp", "==", "\"exposure-fusion\"", ":", "logging", ".", "info", "(", "'exposure fusion...'", ")", "elif", "pp", "==", "\"transfer-colors\"", ":", "logging", ".", "info", "(", "'color transfering...'", ")", "elif", "pp", "==", "\"super-res\"", ":", "logging", ".", "info", "(", "'super-resolution processing...'", ")", "else", ":", "logging", ".", "info", "(", "'wrong post-processing task!'", ")", "return", "output" ]

[ "Post", "-", "processing", "function", ";", "adjust", "it", "with", "your", "custom", "pp", "functions", "." ]

[ "\"\"\" Post-processing function; adjust it with your custom pp functions. \"\"\"", "# denoising code goes here\r", "# chromatic adaptation code goes here\r", "# deblurring code goes here\r", "# dehazing code goes here\r", "# local detail enhancement code goes here\r", "# exposure fusion code goes here\r", "# color transfer code goes here\r", "# you may need to use the 'opt' variable here\r", "# super resolution code goes here\r" ]

[ { "param": "input_img", "type": null }, { "param": "PP", "type": null }, { "param": "opt", "type": null } ]

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

[ "MIT" ]

[ "Calculate", "the", "\"", "brightness", "\"", "of", "a", "color", ".", "and", "yes", "I", "know", "this", "is", "a", "debated", "subject", "but", "this", "way", "works", "for", "just", "fine", "my", "purposes", "." ]

[ "def", "rgb_2_luma", "(", "color", ":", "tuple", ")", "->", "int", ":", "r", ",", "g", ",", "b", "=", "color", "[", "0", "]", "/", "255", ",", "color", "[", "1", "]", "/", "255", ",", "color", "[", "2", "]", "/", "255", "l", "=", "0.33", "*", "r", "+", "0.5", "*", "g", "+", "0.16", "*", "b", "return", "round", "(", "l", ",", "2", ")" ]

[ "Calculate", "the", "\"", "brightness", "\"", "of", "a", "color", "." ]

[ "\"\"\"\n Calculate the \"brightness\" of a color.\n\n ...and, yes I know this is a debated subject\n but this way works for just fine my purposes.\n\n :param color: a tuple of RGB color values eg. (255, 255, 255)\n :returns: luminance \"brightness\" value\n \"\"\"" ]

[ { "param": "color", "type": "tuple" } ]

{ "returns": [ { "docstring": "luminance \"brightness\" value", "docstring_tokens": [ "luminance", "\"", "brightness", "\"", "value" ], "type": null } ], "raises": [], "params": [ { "identifier": "color", "type": "tuple", "docstring": "a tuple of RGB color values eg.", "docstring_tokens": [ "a", "tuple", "of", "RGB", "color", "values", "eg", "." ], "default": null, "is_optional": null } ], "outlier_params": [], "others": [] }

[ "MIT" ]

[ "Check", "if", "list", "length", "is", "one", "or", "two", ".", "So", "far", "only", "used", "in", "StandorteigenschaftenGas", "." ]

[ "def", "check_list_length_is_one_or_two", "(", "instance", ",", "attribute", ",", "value", ")", ":", "if", "len", "(", "value", ")", "==", "0", ":", "raise", "ValueError", "(", "f\"{attribute.name} must not be empty.\"", ")", "if", "len", "(", "value", ")", ">", "2", ":", "raise", "ValueError", "(", "f\"Maximum number of {attribute.name} is 2.\"", ")" ]

[ "Check", "if", "list", "length", "is", "one", "or", "two", "." ]

[ "\"\"\"\n Check if list length is one or two.\n So far only used in StandorteigenschaftenGas.\n \"\"\"" ]

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

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

[ "MIT" ]

[ "Method", "that", "writes", "a", "little", "message" ]

[ "def", "journalizer", "(", "flag", ",", "iter", ",", "phase", ",", "message", ")", ":", "iter", "=", "str", "(", "iter", ")", "print", "(", "\"-\"", "*", "120", ")", "if", "flag", "==", "'W'", ":", "print", "(", "flag", "+", "iter", "+", "\"[[\"", "+", "phase", "+", "\"]]\"", "+", "message", "+", "\".\"", ",", "file", "=", "sys", ".", "stderr", ")", "elif", "flag", "==", "'E'", ":", "print", "(", "flag", "+", "iter", "+", "\"[[\"", "+", "phase", "+", "\"]]\"", "+", "message", "+", "\".\"", ",", "file", "=", "sys", ".", "stderr", ")", "else", ":", "print", "(", "flag", "+", "iter", "+", "\"[[\"", "+", "phase", "+", "\"]]\"", "+", "message", "+", "\".\"", "+", "\"-\"", "*", "20", ")" ]

[ "Method", "that", "writes", "a", "little", "message" ]

[ "\"\"\"Method that writes a little message\n Args:\n flag (str): The flag\n iter (int): The current iteration\n phase (str): The phase\n message (str): The text message to display\n Returns:\n None\"\"\"", "# print to file warning", "# print to file error", "#print(\"-\" * 120)" ]

[ { "param": "flag", "type": null }, { "param": "iter", "type": null }, { "param": "phase", "type": null }, { "param": "message", "type": null } ]

{ "returns": [ { "docstring": null, "docstring_tokens": [ "None" ], "type": null } ], "raises": [], "params": [ { "identifier": "flag", "type": null, "docstring": null, "docstring_tokens": [ "None" ], "default": null, "is_optional": false }, { "identifier": "iter", "type": null, "docstring": "The current iteration", "docstring_tokens": [ "The", "current", "iteration" ], "default": null, "is_optional": false }, { "identifier": "phase", "type": null, "docstring": null, "docstring_tokens": [ "None" ], "default": null, "is_optional": false }, { "identifier": "message", "type": null, "docstring": "The text message to display", "docstring_tokens": [ "The", "text", "message", "to", "display" ], "default": null, "is_optional": false } ], "outlier_params": [], "others": [] }

[ "MIT" ]

[ "Add", "PKCS#1", "padding", "to", "**", "message", "**", ".", "todo", "::", "What", "version", "of", "PKCS#1", ".", "The", "double", "-", "backslashes", "in", "the", "following", "bytestrings", "are", "so", "that", "Sphinx", "renders", "them", "properly", ".", "Each", "double", "-", "backslash", "is", "should", "actually", "only", "be", "a", "single", "backslash", "in", "the", "code", ".", "Each", "block", "is", "128", "bytes", "total", "in", "size", "." ]

[ "def", "addPKCS1Padding", "(", "message", ")", ":", "padding", "=", "b''", "typeinfo", "=", "b'\\x00\\x01'", "separator", "=", "b'\\x00'", "for", "x", "in", "range", "(", "125", "-", "len", "(", "message", ")", ")", ":", "padding", "+=", "b'\\xFF'", "PKCS1paddedMessage", "=", "typeinfo", "+", "padding", "+", "separator", "+", "message", "assert", "len", "(", "PKCS1paddedMessage", ")", "==", "128", "return", "PKCS1paddedMessage" ]

[ "Add", "PKCS#1", "padding", "to", "**", "message", "**", "." ]

[ "\"\"\"Add PKCS#1 padding to **message**.\n \n .. todo:: What version of PKCS#1? PKCS#1 v1.0? See\n https://bugs.torproject.org/13042.\n \n .. The double-backslashes in the following bytestrings are so that Sphinx\n renders them properly. Each double-backslash is should actually only\n be a single backslash in the code.\n\n Each block is 128 bytes total in size:\n\n * 2 bytes for the type info ('\\\\x00\\\\x01')\n * 1 byte for the separator ('\\\\x00')\n * variable length padding ('\\\\xFF')\n * variable length for the **message**\n\n :param str message: The message will be encoded as bytes before adding\n PKCS#1 padding.\n :rtype: bytes\n :returns: The PKCS#1 padded message.\n \"\"\"", "#if sys.version_info.major == 3:", "# if isinstance(message, unicode):", "# message = codecs.latin_1_encode(message, 'replace')[0]", "#else:", "# if isinstance(message, str):", "# message = codecs.latin_1_encode(message, 'replace')[0]" ]

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

{ "returns": [ { "docstring": "The PKCS#1 padded message.", "docstring_tokens": [ "The", "PKCS#1", "padded", "message", "." ], "type": "bytes" } ], "raises": [], "params": [ { "identifier": "message", "type": null, "docstring": "The message will be encoded as bytes before adding\nPKCS#1 padding.", "docstring_tokens": [ "The", "message", "will", "be", "encoded", "as", "bytes", "before", "adding", "PKCS#1", "padding", "." ], "default": null, "is_optional": false } ], "outlier_params": [], "others": [] }

[ "MIT" ]

[ "Writes", "choses", "candidates", "to", "an", "output", "file" ]

[ "def", "write_file", "(", "buffer", ",", "outfile", ")", ":", "file_handler", "=", "open", "(", "outfile", ",", "'w'", ")", "for", "line", "in", "buffer", ":", "file_handler", ".", "write", "(", "line", ".", "strip", "(", ")", "+", "'\\n'", ")", "file_handler", ".", "close", "(", ")", "outfile_size", "=", "str", "(", "(", "int", "(", "os", ".", "path", ".", "getsize", "(", "outfile", ")", "/", "1000000", ")", ")", ")", "print", "(", "\"Wrote to {}: {} MB\"", ".", "format", "(", "outfile", ",", "outfile_size", ")", ")" ]

[ "Writes", "choses", "candidates", "to", "an", "output", "file" ]

[ "\"\"\"\n Writes choses candidates to an output file\n \"\"\"" ]

[ { "param": "buffer", "type": null }, { "param": "outfile", "type": null } ]

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

[ "MIT" ]

[ "Run", "val_foo", "with", "no", "inputs", "test", "whether", "it", "raises", "an", "error" ]

[ "def", "no_error", "(", "val_foo", ",", "give_val", "=", "False", ")", ":", "try", ":", "val", "=", "val_foo", "(", ")", "success", "=", "True", "except", ":", "val", "=", "None", "success", "=", "False", "if", "give_val", ":", "return", "success", ",", "val", "else", ":", "return", "success" ]

[ "Run", "val_foo", "with", "no", "inputs", "test", "whether", "it", "raises", "an", "error" ]

[ "\"\"\"Run val_foo with no inputs, test whether it raises an error\"\"\"" ]

[ { "param": "val_foo", "type": null }, { "param": "give_val", "type": null } ]

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

[ "Apache-2.0" ]

[ "parse", "given", "section", "of", "configuration", "file", "and", "set", "the", "values", "of", "args", ".", "Even", "if", "the", "values", "parsed", "from", "the", "configuration", "file", "already", "exist", "in", "args", "the", "values", "are", "overwritten", "." ]

[ "def", "_parse_cfg_and_overwrite", "(", "config_path", ",", "section", ",", "args", ")", ":", "if", "config_path", "==", "None", ":", "return", "config", "=", "configparser", ".", "ConfigParser", "(", ")", "config", ".", "optionxform", "=", "str", "parsed", "=", "config", ".", "read", "(", "config_path", ")", "if", "not", "parsed", ":", "raise", "FileNotFoundError", "(", "'Not found given configuration file'", ")", "if", "not", "config", ".", "has_section", "(", "section", ")", ":", "raise", "AssertionError", "(", "'configuration file doesn\\'t have \\''", "+", "section", "+", "'\\' section'", ")", "for", "key", "in", "config", "[", "section", "]", ":", "setattr", "(", "args", ",", "key", ",", "config", "[", "section", "]", "[", "key", "]", ")" ]

[ "parse", "given", "section", "of", "configuration", "file", "and", "set", "the", "values", "of", "args", "." ]

[ "\"\"\"\n parse given section of configuration file and set the values of args.\n Even if the values parsed from the configuration file already exist in args,\n the values are overwritten.\n \"\"\"", "# DO NOTHING", "# make option names case sensitive", "# TODO support accumulated arguments" ]

[ { "param": "config_path", "type": null }, { "param": "section", "type": null }, { "param": "args", "type": null } ]

{ "returns": [], "raises": [], "params": [ { "identifier": "config_path", "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": "args", "type": null, "docstring": null, "docstring_tokens": [], "default": null, "is_optional": null } ], "outlier_params": [], "others": [] }

[ "MIT" ]

[ "create", "manifest", "object", "write", "manifest", "to", "file", "use", "manifest", "for", "bulk", "download" ]

[ "def", "download_xml_manifest", "(", "files_res", ",", "dest", ")", ":", "select", "=", "[", "'file_id'", ",", "'file_name'", ",", "'md5sum'", ",", "'file_size'", ",", "'state'", "]", "manifest", "=", "files_res", "[", "select", "]", "manifest", ".", "columns", "=", "[", "'id'", ",", "'filename'", ",", "'md5'", ",", "'size'", ",", "'state'", "]", "manifest", "=", "manifest", ".", "sort_values", "(", "by", "=", "[", "'id'", "]", ")", "out_file", "=", "dest", "+", "'manifest.tsv'", "manifest", ".", "to_csv", "(", "out_file", ",", "sep", "=", "'\\t'", ",", "index", "=", "False", ")", "cmd", "=", "' '", ".", "join", "(", "[", "'gdc-client download'", ",", "'-m'", ",", "out_file", ",", "'-d'", ",", "dest", "]", ")", "subprocess", ".", "call", "(", "cmd", ",", "shell", "=", "True", ")", "print", "(", "'manifest downloaded'", ")" ]

[ "create", "manifest", "object", "write", "manifest", "to", "file", "use", "manifest", "for", "bulk", "download" ]

[ "'''\n -- create manifest object\n -- write manifest to file\n -- use manifest for bulk download\n '''" ]

[ { "param": "files_res", "type": null }, { "param": "dest", "type": null } ]

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

[ "MIT" ]

[ "Format", "epoc", "secs", "to", "a", "time", "string", "suitable", "for", "If", "-", "Modified", "-", "Since", "request", "header", "Example", ":", "'", "Wed", "21", "Oct", "2015", "07", ":", "28", ":", "00", "GMT" ]

[ "def", "format_date", "(", "epocsecs", ")", ":", "t", "=", "time", ".", "gmtime", "(", "epocsecs", ")", "s", "=", "\"Mon Tue Wed Thu Fri Sat Sun\"", ".", "split", "(", ")", "[", "t", ".", "tm_wday", "]", "+", "\", \"", "s", "+=", "\"%02d \"", "%", "(", "t", ".", "tm_mday", ",", ")", "s", "+=", "\"Jan Feb Mar Apr May Jun Jul Aug Sep Oct Nov Dec\"", ".", "split", "(", ")", "[", "t", ".", "tm_mon", "-", "1", "]", "+", "\" \"", "s", "+=", "\"%d %02d:%02d:%02d GMT\"", "%", "(", "t", ".", "tm_year", ",", "t", ".", "tm_hour", ",", "t", ".", "tm_min", ",", "t", ".", "tm_sec", ")", "return", "s" ]

[ "Format", "epoc", "secs", "to", "a", "time", "string", "suitable", "for", "If", "-", "Modified", "-", "Since", "request", "header", "Example", ":", "'", "Wed", "21", "Oct", "2015", "07", ":", "28", ":", "00", "GMT" ]

[ "\"\"\"Format epoc secs to a time string suitable for If-Modified-Since request header\n Example: 'Wed, 21 Oct 2015 07:28:00 GMT'\"\"\"", "# rolling own, as time.strftime is in part locale-dependent (e.g. '%a' for short weekday)" ]

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

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

[ "Apache-2.0" ]

[ "Normalise", "form", "number", "to", "be", "F", "{", "number", "}", "format" ]

[ "def", "normalise_form_number", "(", "cls", ",", "value", ":", "str", ")", "->", "str", ":", "if", "value", "and", "not", "value", ".", "startswith", "(", "\"F\"", ")", ":", "return", "\"F\"", "+", "value", "return", "value" ]

[ "Normalise", "form", "number", "to", "be", "F", "{", "number", "}", "format" ]

[ "\"\"\"\n Normalise form number to be F{number} format\n :param value:\n :return:\n \"\"\"" ]

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

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

[ "MIT" ]

[ "base64", "decode", "data", "will", "convert", "given", "strings", "to", "bytes", ".", "Returns", "base64", "decoded", "value", "as", "a", "string", "or", "bytes", "as", "appropriate", "." ]

[ "def", "base64_decode", "(", "data", ")", ":", "if", "type", "(", "data", ")", "==", "str", ":", "data", "=", "str", ".", "encode", "(", "data", ")", "try", ":", "return", "base64", ".", "decodebytes", "(", "data", ")", ".", "decode", "(", "'utf-8'", ")", "except", "UnicodeDecodeError", ":", "return", "base64", ".", "decodebytes", "(", "data", ")" ]

[ "base64", "decode", "data", "will", "convert", "given", "strings", "to", "bytes", "." ]

[ "\"\"\"\n base64 decode data, will convert given strings to bytes.\n Returns base64 decoded value as a string or bytes as appropriate.\n \"\"\"" ]

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

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

[ "MIT" ]

[ "Read", "a", "file", "and", "slurp", "the", "lines" ]

[ "def", "read_file", "(", "file_name", ":", "str", ")", "->", "list", "[", "str", "]", ":", "logging", ".", "debug", "(", "'Reading from %s'", ",", "file_name", ")", "lines", "=", "[", "]", "try", ":", "with", "open", "(", "file_name", ",", "'rt'", ",", "encoding", "=", "'UTF8'", ")", "as", "infile", ":", "lines", "=", "infile", ".", "readlines", "(", ")", "except", "FileNotFoundError", ":", "logging", ".", "error", "(", "'File not found: %s'", ",", "file_name", ")", "return", "lines" ]

[ "Read", "a", "file", "and", "slurp", "the", "lines" ]

[ "\"\"\"Read a file and slurp the lines\"\"\"" ]

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

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

[ "MIT" ]

[ "This", "is", "a", "private", "method", "used", "only", "by", "the", "Maximal", "Rectangle", "algorithms", "that", "follow", ".", "Given", "an", "overlap", "resulting", "from", "a", "newly", "placed", "case", "and", "a", "space", "this", "method", "split", "the", "space", "in", "maximum", "4", "other", "spaces", "all", "around", "the", "overlap", "." ]

[ "def", "_split", "(", "space", ",", "overlap", ")", ":", "x1", ",", "y1", ",", "sizex1", ",", "sizey1", "=", "space", "x2", ",", "y2", ",", "sizex2", ",", "sizey2", "=", "overlap", "newspaces", "=", "[", "None", ",", "None", ",", "None", ",", "None", "]", "if", "x1", "<", "x2", ":", "newspaces", "[", "0", "]", "=", "(", "x1", ",", "y1", ",", "x2", "-", "x1", ",", "sizey1", ")", "if", "(", "a", ":=", "x1", "+", "sizex1", ")", ">", "(", "b", ":=", "x2", "+", "sizex2", ")", ":", "newspaces", "[", "1", "]", "=", "(", "b", ",", "y1", ",", "a", "-", "b", ",", "sizey1", ")", "if", "y1", "<", "y2", ":", "newspaces", "[", "2", "]", "=", "(", "x1", ",", "y1", ",", "sizex1", ",", "y2", "-", "y1", ")", "if", "(", "a", ":=", "y1", "+", "sizey1", ")", ">", "(", "b", ":=", "y2", "+", "sizey2", ")", ":", "newspaces", "[", "3", "]", "=", "(", "x1", ",", "b", ",", "sizex1", ",", "a", "-", "b", ")", "return", "list", "(", "filter", "(", "None", ",", "newspaces", ")", ")" ]

[ "This", "is", "a", "private", "method", "used", "only", "by", "the", "Maximal", "Rectangle", "algorithms", "that", "follow", "." ]

[ "\"\"\"\n This is a private method used only by the Maximal Rectangle algorithms that follow.\n\n Given an overlap resulting from a newly placed case and a space, this method\n split the space in maximum 4 other spaces all around the overlap.\n\n :param space: The space\n :param overlap: The overlap\n :return: The list of new spaces that will replace the original one.\n\n \"\"\"" ]

[ { "param": "space", "type": null }, { "param": "overlap", "type": null } ]

{ "returns": [ { "docstring": "The list of new spaces that will replace the original one.", "docstring_tokens": [ "The", "list", "of", "new", "spaces", "that", "will", "replace", "the", "original", "one", "." ], "type": null } ], "raises": [], "params": [ { "identifier": "space", "type": null, "docstring": null, "docstring_tokens": [ "None" ], "default": null, "is_optional": null }, { "identifier": "overlap", "type": null, "docstring": null, "docstring_tokens": [ "None" ], "default": null, "is_optional": null } ], "outlier_params": [], "others": [] }

[ "MIT" ]

[ "A", "Mock", "cloud", "instance", "that", "is", "reset", "after", "each", "test", "function", "without", "ssl", "." ]

[ "def", "mock_cloud_private_nossl", "(", "mock_cloud_nossl", ")", ":", "domain", ",", "cloud", "=", "mock_cloud_nossl", "cloud", ".", "reset", "(", ")", "yield", "domain", ",", "cloud", "cloud", ".", "reset", "(", ")" ]

[ "A", "Mock", "cloud", "instance", "that", "is", "reset", "after", "each", "test", "function", "without", "ssl", "." ]

[ "\"\"\"A Mock cloud instance that is reset after each test function without ssl.\"\"\"" ]

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

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

[ "BSD-3-Clause" ]

[ "Return", "True", "if", "value", "is", "a", "repository", "URL", "." ]

[ "def", "is_repo_url", "(", "value", ")", ":", "REPO_REGEX", "=", "re", ".", "compile", "(", "r\"\"\"\n # something like git:// ssh:// file:// etc.\n ((((git|hg)\\+)?(git|ssh|file|https?):(//)?)\n | # or\n (\\w+@[\\w\\.]+) # something like user@...\n )\n \"\"\"", ",", "re", ".", "VERBOSE", ",", ")", "return", "bool", "(", "REPO_REGEX", ".", "match", "(", "value", ")", ")" ]

[ "Return", "True", "if", "value", "is", "a", "repository", "URL", "." ]

[ "\"\"\"Return True if value is a repository URL.\"\"\"" ]

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

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

[ "MIT" ]

[ "Toggles", "the", "layer", "(", "enables", "it", "if", "not", "active", "and", "vise", "versa", ")" ]

[ "def", "tg_pressed", "(", "key", ",", "state", ",", "*", "args", ",", "**", "kwargs", ")", ":", "try", ":", "del_idx", "=", "state", ".", "active_layers", ".", "index", "(", "key", ".", "meta", ".", "layer", ")", "del", "state", ".", "active_layers", "[", "del_idx", "]", "except", "ValueError", ":", "state", ".", "active_layers", ".", "insert", "(", "0", ",", "key", ".", "meta", ".", "layer", ")", "return", "state" ]

[ "Toggles", "the", "layer", "(", "enables", "it", "if", "not", "active", "and", "vise", "versa", ")" ]

[ "'''\n Toggles the layer (enables it if not active, and vise versa)\n '''", "# See mo_released for implementation details around this" ]

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

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

[ "MIT" ]

[ "Makes", "the", "list", "of", "lists", "into", "a", "list", "." ]

[ "def", "_linearise_args", "(", "ll", ")", ":", "if", "ll", "is", "None", ":", "return", "None", "res", "=", "[", "]", "for", "el", "in", "ll", ":", "if", "isinstance", "(", "el", ",", "list", ")", ":", "res", ".", "extend", "(", "el", ")", "else", ":", "res", ".", "append", "(", "el", ")", "return", "res" ]

[ "Makes", "the", "list", "of", "lists", "into", "a", "list", "." ]

[ "\"Makes the list of lists into a list.\"" ]

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

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

[ "Apache-2.0" ]

[ "Given", "the", "file", "path", "containing", "mapping", "information", "of", "line", "image", "and", "transcription", "it", "returns", "a", "dict", ".", "The", "dict", "contains", "this", "mapping", "info", ".", "It", "can", "be", "accessed", "via", "line_id", "and", "will", "provide", "transcription", "." ]

[ "def", "read_image_text", "(", "image_text_path", ")", ":", "image_transcription_dict", "=", "dict", "(", ")", "with", "open", "(", "image_text_path", ",", "encoding", "=", "'utf-8'", ")", "as", "f", ":", "for", "line", "in", "f", ":", "line_vect", "=", "line", ".", "strip", "(", ")", ".", "split", "(", "' '", ")", "image_path", "=", "line_vect", "[", "0", "]", "line_id", "=", "os", ".", "path", ".", "basename", "(", "image_path", ")", ".", "split", "(", "'.png'", ")", "[", "0", "]", "transcription", "=", "line_vect", "[", "1", ":", "]", "joined_transcription", "=", "list", "(", ")", "for", "word", "in", "transcription", ":", "joined_transcription", ".", "append", "(", "word", ")", "joined_transcription", "=", "\" \"", ".", "join", "(", "joined_transcription", ")", "image_transcription_dict", "[", "line_id", "]", "=", "joined_transcription", "return", "image_transcription_dict" ]

[ "Given", "the", "file", "path", "containing", "mapping", "information", "of", "line", "image", "and", "transcription", "it", "returns", "a", "dict", "." ]

[ "\"\"\" Given the file path containing, mapping information of line image\n and transcription, it returns a dict. The dict contains this mapping\n info. It can be accessed via line_id and will provide transcription.\n Returns:\n --------\n dict: line_id and transcription mapping\n \"\"\"" ]

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

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

[ "MIT" ]

[ "convert", "object", "to", "primitive", "type", "so", "we", "can", "serialize", "it", "to", "data", "format", "like", "python", ".", "all", "primitive", "types", ":", "dict", "list", "int", "float", "bool", "str", "None" ]

[ "def", "object_to_primitive", "(", "obj", ")", ":", "if", "obj", "is", "None", ":", "return", "obj", "if", "isinstance", "(", "obj", ",", "(", "int", ",", "float", ",", "bool", ",", "str", ")", ")", ":", "return", "obj", "if", "isinstance", "(", "obj", ",", "(", "list", ",", "frozenset", ",", "set", ")", ")", ":", "return", "[", "object_to_primitive", "(", "x", ")", "for", "x", "in", "obj", "]", "if", "isinstance", "(", "obj", ",", "dict", ")", ":", "return", "dict", "(", "[", "(", "object_to_primitive", "(", "k", ")", ",", "object_to_primitive", "(", "v", ")", ")", "for", "k", ",", "v", "in", "obj", ".", "items", "(", ")", "]", ")", "data", "=", "vars", "(", "obj", ")", "assert", "isinstance", "(", "data", ",", "dict", ")", "return", "object_to_primitive", "(", "data", ")" ]

[ "convert", "object", "to", "primitive", "type", "so", "we", "can", "serialize", "it", "to", "data", "format", "like", "python", "." ]

[ "'''\n convert object to primitive type so we can serialize it to data format like python.\n\n all primitive types: dict, list, int, float, bool, str, None\n '''" ]

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

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

[ "Apache-2.0" ]

[ "Exchange", "state", "and", "energies", "of", "two", "replicas", ".", "This", "function", "exchanges", "current", "states", "and", "energies", "between", "replicas", ".", "All", "other", "properties", "of", "replicas", "stay", "the", "same", ".", "In", "particular", "best", "energies", "and", "best", "states", "found", "so", "far", "by", "each", "replica", "remain", "unchanged", ".", "Temperatures", "(", "beta", ")", "also", "remain", "unchanged", ".", "This", "is", "important", "for", "the", "implementation", "of", "PTSampler", "." ]

[ "def", "exchange_states", "(", "replica_1", ",", "replica_2", ")", ":", "replica_1", ".", "current_energy", ",", "replica_2", ".", "current_energy", "=", "(", "replica_2", ".", "current_energy", ",", "replica_1", ".", "current_energy", ",", ")", "replica_1", ".", "current_state", ",", "replica_2", ".", "current_state", "=", "(", "replica_2", ".", "current_state", ",", "replica_1", ".", "current_state", ",", ")" ]

[ "Exchange", "state", "and", "energies", "of", "two", "replicas", "." ]

[ "\"\"\"Exchange state and energies of two replicas.\n\n This function exchanges current states and energies between replicas.\n All other properties of replicas stay the same. In particular, best energies\n and best states found so far by each replica remain unchanged. Temperatures (beta)\n also remain unchanged. This is important for the implementation of PTSampler.\n \"\"\"" ]

[ { "param": "replica_1", "type": null }, { "param": "replica_2", "type": null } ]

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

[ "MIT" ]

[ "Builds", "an", "appointment", "from", "a", "dictionary", "." ]

[ "def", "from_dict", "(", "cls", ",", "appointment_data", ")", ":", "locator", "=", "appointment_data", ".", "get", "(", "\"locator\"", ")", "encrypted_blob", "=", "appointment_data", ".", "get", "(", "\"encrypted_blob\"", ")", "to_self_delay", "=", "appointment_data", ".", "get", "(", "\"to_self_delay\"", ")", "if", "any", "(", "v", "is", "None", "for", "v", "in", "[", "locator", ",", "to_self_delay", ",", "encrypted_blob", "]", ")", ":", "raise", "ValueError", "(", "\"Wrong appointment data, some fields are missing\"", ")", "return", "cls", "(", "locator", ",", "encrypted_blob", ",", "to_self_delay", ")" ]

[ "Builds", "an", "appointment", "from", "a", "dictionary", "." ]

[ "\"\"\"\n Builds an appointment from a dictionary.\n\n Args:\n appointment_data (:obj:`dict`): a dictionary containing the following keys:\n ``{locator, to_self_delay, encrypted_blob}``\n\n Returns:\n :obj:`Appointment`: An appointment initialized using the provided data.\n\n Raises:\n ValueError: If one of the mandatory keys is missing in ``appointment_data``.\n \"\"\"" ]

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

{ "returns": [ { "docstring": ":obj:`Appointment`: An appointment initialized using the provided data.", "docstring_tokens": [ ":", "obj", ":", "`", "Appointment", "`", ":", "An", "appointment", "initialized", "using", "the", "provided", "data", "." ], "type": null } ], "raises": [ { "docstring": "If one of the mandatory keys is missing in ``appointment_data``.", "docstring_tokens": [ "If", "one", "of", "the", "mandatory", "keys", "is", "missing", "in", "`", "`", "appointment_data", "`", "`", "." ], "type": "ValueError" } ], "params": [ { "identifier": "cls", "type": null, "docstring": null, "docstring_tokens": [], "default": null, "is_optional": null }, { "identifier": "appointment_data", "type": null, "docstring": null, "docstring_tokens": [], "default": null, "is_optional": null } ], "outlier_params": [ { "identifier": "appointment_data (", "type": null, "docstring": "`dict`): a dictionary containing the following keys:\n``{locator, to_self_delay, encrypted_blob}``", "docstring_tokens": [ "`", "dict", "`", ")", ":", "a", "dictionary", "containing", "the", "following", "keys", ":", "`", "`", "{", "locator", "to_self_delay", "encrypted_blob", "}", "`", "`" ], "default": null, "is_optional": null } ], "others": [] }

[ "MIT" ]

[ "Return", "the", "MAC", "address", "and", "interface", "name", "used", "to", "reach", "the", "given", "host", "Returns", "usable", "strings", "on", "error", ".", "string", "name", "of", "the", "target", "host", "Returns", ":", "string", "name", "and", "string", "form", "of", "MAC", "address", "of", "interface", "used", "to", "reach", "the", "given", "host" ]

[ "def", "macAddress", "(", "hostname", ")", ":", "ipAddr", "=", "socket", ".", "gethostbyname", "(", "hostname", ")", "match", "=", "re", ".", "search", "(", "r\"^.* dev (.*?) .*$\"", ",", "str", "(", "subprocess", ".", "check_output", "(", "[", "\"ip\"", ",", "\"route\"", ",", "\"get\"", ",", "ipAddr", "]", ")", ")", ")", "if", "not", "match", ":", "logging", ".", "warning", "(", "f\"Unable to find interface for {ipAddr}\"", ")", "return", "\"n/a\"", ",", "\"00:00:00:00:00:00\"", "intf", "=", "match", ".", "group", "(", "1", ")", "try", ":", "macAddr", "=", "subprocess", ".", "check_output", "(", "[", "\"cat\"", ",", "f\"/sys/class/net/{intf}/address\"", "]", ")", ".", "strip", "(", ")", ".", "decode", "(", "\"utf-8\"", ")", "except", "Exception", "as", "ex", ":", "logging", ".", "warning", "(", "\"Failed to get MAC address for '{hostname}': {ex}\"", ")", "return", "\"n/a\"", ",", "\"00:00:00:00:00:00\"", "return", "intf", ",", "macAddr" ]

[ "Return", "the", "MAC", "address", "and", "interface", "name", "used", "to", "reach", "the", "given", "host", "Returns", "usable", "strings", "on", "error", "." ]

[ "\"\"\"Return the MAC address and interface name used to reach the given host\n\n Returns usable strings on error.\n\n Inputs:\n hostname: string name of the target host\n Returns: string name and string form of MAC address of interface used to\n reach the given host\n \"\"\"" ]

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

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

[ "Apache-2.0" ]

[ "Create", "a", "string", "w", "/", "the", "list", "of", "instance", "formatted", "to", "be", "mailed" ]

[ "def", "format_user_instances", "(", "user", ")", ":", "text", "=", "\"\"", "for", "instance", "in", "user", ":", "text", "+=", "\" - {name} started {created_at} and expire {lease_end} \\n\"", ".", "format", "(", "**", "instance", ")", "return", "text" ]

[ "Create", "a", "string", "w", "/", "the", "list", "of", "instance", "formatted", "to", "be", "mailed" ]

[ "\"\"\"\n Create a string w/ the list of instance formatted to be mailed\n :param user: user we currently notify\n :return: string\n \"\"\"" ]

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

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

[ "MIT" ]

[ "Parse", "string", "s", "as", "float", "and", "return", ";", "return", "nan", "on", "failure", "." ]

[ "def", "makeFloat", "(", "s", ")", ":", "try", ":", "return", "float", "(", "s", ")", "except", "Exception", ":", "return", "float", "(", "'nan'", ")" ]

[ "Parse", "string", "s", "as", "float", "and", "return", ";", "return", "nan", "on", "failure", "." ]

[ "\"\"\"Parse string s as float and return; return nan on failure.\"\"\"" ]

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

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

[ "MIT" ]

[ "Ensure", "directory", "exists", ".", "Create", "if", "necessary", "." ]

[ "def", "ensure_dir_exists", "(", "verify_dir", ")", ":", "if", "not", "os", ".", "path", ".", "exists", "(", "verify_dir", ")", ":", "os", ".", "makedirs", "(", "verify_dir", ")", "else", ":", "if", "not", "os", ".", "path", ".", "isdir", "(", "verify_dir", ")", ":", "raise", "ValueError", "(", "f\"{verify_dir} is not a directory\"", ")" ]

[ "Ensure", "directory", "exists", "." ]

[ "\"\"\"Ensure directory exists. Create if necessary.\"\"\"", "# Doesn't exist create dir", "# Exists", "# Not a dir, raise an exception" ]

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

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

[ "MIT" ]

[ "query", "API", "call", "details", "via", "hist" ]

[ "def", "query_api_hist", "(", "conn", ",", "username", ")", ":", "cursor", "=", "conn", ".", "cursor", "(", ")", "sql", "=", "\"SELECT api_name, COUNT(api_name) FROM api WHERE 1=1\"", "if", "username", "is", "not", "None", "and", "username", "!=", "''", ":", "sql", "+=", "\" AND username='{0}'\"", ".", "format", "(", "username", ")", "cursor", ".", "execute", "(", "sql", ")", "results", "=", "cursor", ".", "fetchall", "(", ")", "db_result", "=", "{", "}", "for", "k", ",", "v", "in", "results", ":", "db_result", "[", "k", "]", "=", "v", "conn", ".", "close", "(", ")", "return", "db_result" ]

[ "query", "API", "call", "details", "via", "hist" ]

[ "\"\"\"\n query API call details via hist\n :param conn:\n :param username:\n :return:\n \"\"\"" ]

[ { "param": "conn", "type": null }, { "param": "username", "type": null } ]

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

[ "MIT" ]

[ "Print", "an", "info", "message", "on", "the", "console", ".", "Warning", "messages", "are", "cyan" ]

[ "def", "_info", "(", "message", ",", "colored", "=", "True", ")", ":", "if", "colored", ":", "print", "(", "'\\033[96m{}\\033[00m'", ".", "format", "(", "message", ")", ")", "else", ":", "print", "(", "message", ")" ]

[ "Print", "an", "info", "message", "on", "the", "console", "." ]

[ "\"\"\"\n Print an info message on the console. Warning messages are cyan\n \"\"\"" ]

[ { "param": "message", "type": null }, { "param": "colored", "type": null } ]

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

[ "MIT" ]

[ "conditional", "that", "is", "true", "on", "every", "Nth", "sample" ]

[ "def", "downsample", "(", "N", ")", ":", "global", "_downsample_N", "_downsample_N", "=", "(", "_downsample_N", "+", "1", ")", "%", "N", "return", "_downsample_N", "==", "0" ]

[ "conditional", "that", "is", "true", "on", "every", "Nth", "sample" ]

[ "'''conditional that is true on every Nth sample'''" ]

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

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

[ "Apache-2.0" ]

[ "Return", "the", "labels", "that", "at", "least", "min_agreement", "raters", "agree", "on", "." ]

[ "def", "CheckAgreement", "(", "ex", ",", "min_agreement", ",", "all_emotions", ",", "max_agreement", "=", "100", ")", ":", "sum_ratings", "=", "ex", "[", "all_emotions", "]", ".", "sum", "(", "axis", "=", "0", ")", "agreement", "=", "(", "(", "sum_ratings", ">=", "min_agreement", ")", "&", "(", "sum_ratings", "<=", "max_agreement", ")", ")", "return", "\",\"", ".", "join", "(", "sum_ratings", ".", "index", "[", "agreement", "]", ".", "tolist", "(", ")", ")" ]

[ "Return", "the", "labels", "that", "at", "least", "min_agreement", "raters", "agree", "on", "." ]

[ "\"\"\"Return the labels that at least min_agreement raters agree on.\"\"\"" ]

[ { "param": "ex", "type": null }, { "param": "min_agreement", "type": null }, { "param": "all_emotions", "type": null }, { "param": "max_agreement", "type": null } ]

{ "returns": [], "raises": [], "params": [ { "identifier": "ex", "type": null, "docstring": null, "docstring_tokens": [], "default": null, "is_optional": null }, { "identifier": "min_agreement", "type": null, "docstring": null, "docstring_tokens": [], "default": null, "is_optional": null }, { "identifier": "all_emotions", "type": null, "docstring": null, "docstring_tokens": [], "default": null, "is_optional": null }, { "identifier": "max_agreement", "type": null, "docstring": null, "docstring_tokens": [], "default": null, "is_optional": null } ], "outlier_params": [], "others": [] }

[ "0BSD" ]

[ "Convert", "a", "decimal", "octet", "into", "an", "integer", "." ]

[ "def", "_parse_octet", "(", "cls", ",", "octet_str", ")", ":", "if", "not", "octet_str", ":", "raise", "ValueError", "(", "\"Empty octet not permitted\"", ")", "if", "not", "(", "octet_str", ".", "isascii", "(", ")", "and", "octet_str", ".", "isdigit", "(", ")", ")", ":", "msg", "=", "\"Only decimal digits permitted in %r\"", "raise", "ValueError", "(", "msg", "%", "octet_str", ")", "if", "len", "(", "octet_str", ")", ">", "3", ":", "msg", "=", "\"At most 3 characters permitted in %r\"", "raise", "ValueError", "(", "msg", "%", "octet_str", ")", "if", "octet_str", "!=", "'0'", "and", "octet_str", "[", "0", "]", "==", "'0'", ":", "msg", "=", "\"Leading zeros are not permitted in %r\"", "raise", "ValueError", "(", "msg", "%", "octet_str", ")", "octet_int", "=", "int", "(", "octet_str", ",", "10", ")", "if", "octet_int", ">", "255", ":", "raise", "ValueError", "(", "\"Octet %d (> 255) not permitted\"", "%", "octet_int", ")", "return", "octet_int" ]

[ "Convert", "a", "decimal", "octet", "into", "an", "integer", "." ]

[ "\"\"\"Convert a decimal octet into an integer.\n\n Args:\n octet_str: A string, the number to parse.\n\n Returns:\n The octet as an integer.\n\n Raises:\n ValueError: if the octet isn't strictly a decimal from [0..255].\n\n \"\"\"", "# Reject non-ASCII digits.", "# We do the length check second, since the invalid character error", "# is likely to be more informative for the user", "# Handle leading zeros as strict as glibc's inet_pton()", "# See security bug bpo-36384", "# Convert to integer (we know digits are legal)" ]

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

{ "returns": [ { "docstring": "The octet as an integer.", "docstring_tokens": [ "The", "octet", "as", "an", "integer", "." ], "type": null } ], "raises": [ { "docstring": "if the octet isn't strictly a decimal from [0..255].", "docstring_tokens": [ "if", "the", "octet", "isn", "'", "t", "strictly", "a", "decimal", "from", "[", "0", "..", "255", "]", "." ], "type": "ValueError" } ], "params": [ { "identifier": "cls", "type": null, "docstring": null, "docstring_tokens": [], "default": null, "is_optional": null }, { "identifier": "octet_str", "type": null, "docstring": "A string, the number to parse.", "docstring_tokens": [ "A", "string", "the", "number", "to", "parse", "." ], "default": null, "is_optional": null } ], "outlier_params": [], "others": [] }

[ "MIT" ]

[ "Create", "new", "quote", "for", "testing", "." ]

[ "def", "new_quote", "(", "quote", ")", ":", "Quote", "=", "quote", "quote_data", "=", "{", "\"quote_text\"", ":", "\"Quote.\"", ",", "\"author_name\"", ":", "\"Author\"", ",", "\"author_image\"", ":", "\"URL\"", ",", "\"tags\"", ":", "[", "\"test-tag\"", "]", ",", "}", "new_quote", "=", "Quote", "(", "**", "quote_data", ")", "new_quote", ".", "save", "(", ")", "return", "new_quote" ]

[ "Create", "new", "quote", "for", "testing", "." ]

[ "\"\"\" Create new quote for testing. \"\"\"", "# Quote mock data" ]

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

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

[ "BSD-2-Clause" ]

[ "get", "peer", "type", "from", "Ion", "object" ]

[ "def", "from_object", "(", "cls", ",", "obj", ")", ":", "mod", "=", "obj", ".", "get_decorator_value", "(", "'peer'", ",", "'module'", ")", "clazz", "=", "obj", ".", "get_decorator_value", "(", "'peer'", ",", "'class'", ")", "or", "obj", ".", "__class__", ".", "__name__", "subclass", "=", "getattr", "(", "sys", ".", "modules", "[", "mod", "]", ",", "clazz", ")", "return", "subclass", "(", "obj", ")" ]

[ "get", "peer", "type", "from", "Ion", "object" ]

[ "\"\"\" get peer type from Ion object \"\"\"" ]

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

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

[ "0BSD" ]

[ "Helper", "function", "to", "get", "leading", "spaces", "." ]

[ "def", "_get_code_spaces", "(", "code_line", ",", "space_char", ",", "number_of_leading_chars", "=", "0", ")", ":", "num_code_spaces", "=", "len", "(", "code_line", ")", "-", "len", "(", "code_line", ".", "lstrip", "(", ")", ")", "num_code_spaces", "=", "num_code_spaces", "+", "number_of_leading_chars", "if", "space_char", "==", "'\\t'", ":", "if", "code_line", "[", ":", "1", "]", "==", "' '", ":", "num_code_spaces", "=", "int", "(", "num_code_spaces", "/", "4", ")", "num_code_spaces", "=", "num_code_spaces", "+", "1", "else", ":", "num_code_spaces", "=", "num_code_spaces", "+", "4", "return", "space_char", ".", "join", "(", "[", "''", "for", "i", "in", "range", "(", "num_code_spaces", "+", "1", ")", "]", ")" ]

[ "Helper", "function", "to", "get", "leading", "spaces", "." ]

[ "\"\"\"Helper function to get leading spaces.\"\"\"" ]

[ { "param": "code_line", "type": null }, { "param": "space_char", "type": null }, { "param": "number_of_leading_chars", "type": null } ]

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

[ "MIT" ]

[ "Compare", "the", "content", "of", "tho", "lists", "regardless", "items", "order", "." ]

[ "def", "compare_lists", "(", "list_a", ",", "list_b", ")", ":", "if", "len", "(", "list_a", ")", "!=", "len", "(", "list_b", ")", ":", "return", "False", "if", "not", "list_a", ":", "return", "True", "value", ",", "*", "new_a", "=", "list_a", "if", "value", "not", "in", "list_b", ":", "return", "False", "new_b", "=", "list", "(", "filter", "(", "lambda", "x", ":", "x", "!=", "value", ",", "list_b", ")", ")", "return", "compare_lists", "(", "new_a", ",", "new_b", ")" ]

[ "Compare", "the", "content", "of", "tho", "lists", "regardless", "items", "order", "." ]

[ "\"\"\"Compare the content of tho lists regardless items order.\"\"\"" ]

[ { "param": "list_a", "type": null }, { "param": "list_b", "type": null } ]

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

[ "Apache-2.0" ]

[ "Check", "if", "the", "given", "value", "is", "None", "or", "empty", "string", "." ]

[ "def", "check_not_none_or_empty", "(", "val", ",", "name", ")", ":", "if", "val", "==", "None", ":", "raise", "ValueError", "(", "'Object '", "+", "name", "+", "' should not be None.'", ")", "if", "not", "isinstance", "(", "val", ",", "str", ")", ":", "raise", "TypeError", "(", "'Object '", "+", "name", "+", "' should be a string.'", ")", "if", "len", "(", "val", ".", "strip", "(", ")", ")", "==", "0", ":", "raise", "ValueError", "(", "'Object '", "+", "name", "+", "' should not empty string.'", ")" ]

[ "Check", "if", "the", "given", "value", "is", "None", "or", "empty", "string", "." ]

[ "'''\n Check if the given value is None or empty string.\n\n @param val: the given value to check\n @param name: name of val\n @raise TypeError: if val is not of type string\n @raise ValueError: if val is None or empty string\n '''" ]

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

{ "returns": [], "raises": [ { "docstring": "if val is not of type string", "docstring_tokens": [ "if", "val", "is", "not", "of", "type", "string" ], "type": "TypeError" }, { "docstring": "if val is None or empty string", "docstring_tokens": [ "if", "val", "is", "None", "or", "empty", "string" ], "type": "ValueError" } ], "params": [ { "identifier": "val", "type": null, "docstring": "the given value to check", "docstring_tokens": [ "the", "given", "value", "to", "check" ], "default": null, "is_optional": false }, { "identifier": "name", "type": null, "docstring": "name of val", "docstring_tokens": [ "name", "of", "val" ], "default": null, "is_optional": false } ], "outlier_params": [], "others": [] }

[ "MIT" ]

[ "Converts", "number", "to", "string", "of", "capital", "letters", "in", "Excel", "column", "name", "fashion", "i", ".", "e", "." ]

[ "def", "convert_to_letters", "(", "num", ")", ":", "string_equiv", "=", "\"\"", "while", "num", ">", "0", ":", "currNum", "=", "(", "num", "-", "1", ")", "%", "26", "num", "=", "(", "num", "-", "1", ")", "//", "26", "string_equiv", "=", "chr", "(", "currNum", "+", "ord", "(", "\"A\"", ")", ")", "+", "string_equiv", "return", "string_equiv" ]

[ "Converts", "number", "to", "string", "of", "capital", "letters", "in", "Excel", "column", "name", "fashion", "i", ".", "e", "." ]

[ "\"\"\"Converts number to string of capital letters in Excel column name\n fashion, i.e. 1 -> A, 26 -> Z, 27 -> AA ....\"\"\"" ]

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

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

[ "BSD-3-Clause" ]

[ "For", "Internal", "Use", "removes", "illegal", "characters", "from", "column", "headings", "and", "truncates", "those", "which", "are", "too", "long", "." ]

[ "def", "_AdjustColHeadings", "(", "colHeadings", ",", "maxColLabelLen", ")", ":", "for", "i", "in", "range", "(", "len", "(", "colHeadings", ")", ")", ":", "colHeadings", "[", "i", "]", "=", "colHeadings", "[", "i", "]", ".", "strip", "(", ")", "colHeadings", "[", "i", "]", "=", "colHeadings", "[", "i", "]", ".", "replace", "(", "' '", ",", "'_'", ")", "colHeadings", "[", "i", "]", "=", "colHeadings", "[", "i", "]", ".", "replace", "(", "'-'", ",", "'_'", ")", "colHeadings", "[", "i", "]", "=", "colHeadings", "[", "i", "]", ".", "replace", "(", "'.'", ",", "'_'", ")", "if", "len", "(", "colHeadings", "[", "i", "]", ")", ">", "maxColLabelLen", ":", "newHead", "=", "colHeadings", "[", "i", "]", ".", "replace", "(", "'_'", ",", "''", ")", "newHead", "=", "newHead", "[", ":", "maxColLabelLen", "]", "print", "(", "'\\tHeading %s too long, changed to %s'", "%", "(", "colHeadings", "[", "i", "]", ",", "newHead", ")", ")", "colHeadings", "[", "i", "]", "=", "newHead", "return", "colHeadings" ]

[ "For", "Internal", "Use", "removes", "illegal", "characters", "from", "column", "headings", "and", "truncates", "those", "which", "are", "too", "long", "." ]

[ "\"\"\" *For Internal Use*\n\n removes illegal characters from column headings\n and truncates those which are too long.\n\n \"\"\"", "# replace unallowed characters and strip extra white space", "# interbase (at least) has a limit on the maximum length of a column name" ]

[ { "param": "colHeadings", "type": null }, { "param": "maxColLabelLen", "type": null } ]

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

[ "MIT" ]

[ "Return", "list", "of", "all", "part", "dictionaries", "within", "toplist", "that", "are", "of", "type", "part_type", "Where", "toplist", "is", "the", "list", "of", "[", "part_type", "part_dict", "]", "items", "as", "read", "by", "read_project", "()" ]

[ "def", "_allparts", "(", "toplist", ",", "part_type", ")", ":", "part_list", "=", "[", "]", "for", "item", "in", "toplist", ":", "item_type", ",", "item_dict", "=", "item", "if", "item_type", "==", "part_type", ":", "part_list", ".", "append", "(", "item_dict", ")", "if", "item_type", "==", "'Widget'", ":", "for", "key", "in", "item_dict", ".", "keys", "(", ")", ":", "if", "\"container_\"", "in", "key", ":", "part_list", ".", "extend", "(", "_allparts", "(", "item_dict", "[", "key", "]", ",", "part_type", ")", ")", "elif", "item_type", "==", "'Part'", ":", "part_list", ".", "extend", "(", "_allparts", "(", "item_dict", "[", "'parts'", "]", ",", "part_type", ")", ")", "elif", "item_type", "==", "'Widget'", ":", "for", "key", "in", "item_dict", ".", "keys", "(", ")", ":", "if", "\"container_\"", "in", "key", ":", "part_list", ".", "extend", "(", "_allparts", "(", "item_dict", "[", "key", "]", ",", "part_type", ")", ")", "return", "part_list" ]

[ "Return", "list", "of", "all", "part", "dictionaries", "within", "toplist", "that", "are", "of", "type", "part_type", "Where", "toplist", "is", "the", "list", "of", "[", "part_type", "part_dict", "]", "items", "as", "read", "by", "read_project", "()" ]

[ "\"\"\"Return list of all part dictionaries within toplist that are of type part_type\n Where toplist is the list of [part_type,part_dict] items as read by read_project()\"\"\"", "# search through parts" ]

[ { "param": "toplist", "type": null }, { "param": "part_type", "type": null } ]

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

[ "BSD-3-Clause" ]

[ "transforms", "azimuth", "(", "angle", "from", "north", "towards", "east", ")", "to", "phi", "(", "angle", "from", "x", "-", "axis", "towards", "y", "-", "axis", ")", "for", "simtel", "array", "coordinate", "systems" ]

[ "def", "az_to_phi", "(", "az", ")", ":", "return", "-", "az" ]

[ "transforms", "azimuth", "(", "angle", "from", "north", "towards", "east", ")", "to", "phi", "(", "angle", "from", "x", "-", "axis", "towards", "y", "-", "axis", ")", "for", "simtel", "array", "coordinate", "systems" ]

[ "\"\"\"transforms azimuth (angle from north towards east) \n to phi (angle from x-axis towards y-axis) \n for simtel array coordinate systems \n \"\"\"" ]

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

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

[ "MIT" ]

[ "string", "of", "(", "possibly", "comma", "-", "and", "semi", "-", "colon", "-", "separated", ")", "authors", "Output", ":", "list", "of", "dicts", "stripped", "of", "empty", "authors", "and", "whitesapce" ]

[ "def", "format_authors", "(", "authors", ")", ":", "list_of_authors", "=", "[", "]", "for", "author", "in", "authors", "[", ":", "]", ".", "split", "(", "\";\"", ")", ":", "if", "any", "(", "char", ".", "isalnum", "(", ")", "for", "char", "in", "author", ")", ":", "author", "=", "author", ".", "split", "(", "\",\"", ",", "maxsplit", "=", "1", ")", "try", ":", "a", "=", "{", "\"last_name\"", ":", "author", "[", "0", "]", ".", "strip", "(", ")", ",", "\"first_name\"", ":", "author", "[", "1", "]", ".", "strip", "(", ")", "}", "except", "IndexError", ":", "a", "=", "{", "\"last_name\"", ":", "author", "[", "0", "]", ".", "strip", "(", ")", ",", "\"first_name\"", ":", "\"\"", "}", "list_of_authors", ".", "append", "(", "a", ")", "return", "list_of_authors" ]

[ "Input", ":", "string", "of", "(", "possibly", "comma", "-", "and", "semi", "-", "colon", "-", "separated", ")", "authors", "Output", ":", "list", "of", "dicts", "stripped", "of", "empty", "authors", "and", "whitesapce" ]

[ "\"\"\" Input: string of (possibly comma- and semi-colon-separated) authors\n Output: list of dicts, stripped of empty authors and whitesapce\n \"\"\"" ]

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

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

[ "MIT" ]

[ "DESCRIPTION", ":", "checks", "if", "the", "given", "region", "is", "Connected", "Segment", "or", "not", ".", "Returns", "True", "if", "it", "the", "given", "region", "is", "a", "valid", "connected", "segment", "False", "if", "it", "is", "a", "stand", "-", "alone", "segment" ]

[ "def", "isSegmentConnector", "(", "r", ")", ":", "if", "(", "'segment_connector'", "in", "r", "[", "'region_attributes'", "]", "and", "r", "[", "'region_attributes'", "]", "[", "'segment_connector'", "]", ".", "strip", "(", ")", ")", ":", "return", "True", "else", ":", "return", "False" ]

[ "Parameters", "r", ":", "region", "type", "with", "format", ":", "{", "\"", "shape_attributes", "\"", ":", "{", "\"", "name", "\"", ":", "\"", "polygon", "\"", "\"", "all_points_x", "\"", ":", "[", "229", "231", "]", "\"", "all_points_y", "\"", ":", "[", "272", "268", "]", "}", "\"", "region_attributes", "\"", ":", "{", "\"", "name", "\"", ":", "\"", "Motorcyclist", "\"", "\"", "segment_connector", "\"", ":", "\"", "\"", "}", "\"", "ignore", "\"", ":", "False", "\"", "with_helmet", "\"", ":", "False", "}" ]

[ "\"\"\"\n\n Parameters\n ----------\n r : region type with format :\n {\n \t\"shape_attributes\": {\n \t\t\"name\": \"polygon\",\n \t\t\"all_points_x\": [\n \t\t\t229,231,\n \t\t],\n \t\t\"all_points_y\": [\n \t\t\t272,268,\n \t\t]\n \t},\n \t\"region_attributes\": {\n \t\t\"name\": \"Motorcyclist\",\n \t\t\"segment_connector\": \" \"\n \t}\n \"ignore\" : False\n \"with_helmet\" : False\n }\n \n DESCRIPTION : checks if the given region is Connected Segment or not.\n\n Returns\n -------\n True if it the given region is a valid connected segment\n False if it is a stand-alone segment\n\n \"\"\"" ]

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

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

[ "Apache-2.0" ]

[ "Create", "base", "class", "for", "defining", "new", "database", "classes", "." ]

[ "def", "declarative_base", "(", "decl_type", ",", "name", ",", "cls", ",", "metaclass", ",", "**", "kwargs", ")", ":", "bases", "=", "cls", "if", "isinstance", "(", "cls", ",", "tuple", ")", "else", "(", "cls", ",", ")", "class_dict", "=", "dict", "(", "decl_type", "=", "decl_type", ")", "class_dict", ".", "update", "(", "kwargs", ")", "return", "metaclass", "(", "name", ",", "bases", ",", "class_dict", ")" ]

[ "Create", "base", "class", "for", "defining", "new", "database", "classes", "." ]

[ "\"\"\"Create base class for defining new database classes.\n\n :param decl_type: DeclarativeType enum value.\n :param name: Metaclass name\n :param cls: Base class(es) for returned class\n :param metaclass: Metaclass for registering type information\n \"\"\"" ]

[ { "param": "decl_type", "type": null }, { "param": "name", "type": null }, { "param": "cls", "type": null }, { "param": "metaclass", "type": null } ]

{ "returns": [], "raises": [], "params": [ { "identifier": "decl_type", "type": null, "docstring": "DeclarativeType enum value.", "docstring_tokens": [ "DeclarativeType", "enum", "value", "." ], "default": null, "is_optional": null }, { "identifier": "name", "type": null, "docstring": null, "docstring_tokens": [ "None" ], "default": null, "is_optional": null }, { "identifier": "cls", "type": null, "docstring": "Base class(es) for returned class", "docstring_tokens": [ "Base", "class", "(", "es", ")", "for", "returned", "class" ], "default": null, "is_optional": null }, { "identifier": "metaclass", "type": null, "docstring": "Metaclass for registering type information", "docstring_tokens": [ "Metaclass", "for", "registering", "type", "information" ], "default": null, "is_optional": null } ], "outlier_params": [], "others": [] }

[ "MIT" ]

[ "Converts", "a", "ISO", "8601", "unicode", "duration", "str", "to", "milliseconds", "." ]

[ "def", "convert_to_millisecond", "(", "duration", ")", ":", "duration_string", "=", "duration", ".", "replace", "(", "'PT'", ",", "''", ")", ".", "upper", "(", ")", "seconds", "=", "0", "number_string", "=", "''", "for", "char", "in", "duration_string", ":", "if", "char", ".", "isnumeric", "(", ")", ":", "number_string", "+=", "char", "try", ":", "if", "char", "==", "'H'", ":", "seconds", "+=", "(", "int", "(", "number_string", ")", "*", "60", ")", "*", "60", "number_string", "=", "''", "if", "char", "==", "'M'", ":", "seconds", "+=", "int", "(", "number_string", ")", "*", "60", "number_string", "=", "''", "if", "char", "==", "'S'", ":", "seconds", "+=", "int", "(", "number_string", ")", "except", "ValueError", ":", "return", "0", "return", "seconds", "*", "1000" ]

[ "Converts", "a", "ISO", "8601", "unicode", "duration", "str", "to", "milliseconds", "." ]

[ "\"\"\"\r\n Converts a ISO 8601 unicode duration str to milliseconds.\r\n :param duration: The ISO 8601 unicode duration str\r\n :return: int milliseconds\r\n \"\"\"" ]

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

{ "returns": [ { "docstring": null, "docstring_tokens": [ "None" ], "type": null } ], "raises": [], "params": [ { "identifier": "duration", "type": null, "docstring": "The ISO 8601 unicode duration str", "docstring_tokens": [ "The", "ISO", "8601", "unicode", "duration", "str" ], "default": null, "is_optional": null } ], "outlier_params": [], "others": [] }

[ "BSD-2-Clause" ]

[ "Transform", "a", "dataframe", "into", "a", "dictionary", ";", "primarily", "used", "for", "parameter", "setting", "." ]

[ "def", "pdef", "(", "df", ",", "sets", "=", "[", "]", ",", "val", "=", "'value'", ",", "fixnan", "=", "0", ")", ":", "df", "=", "df", ".", "reset_index", "(", "drop", "=", "True", ")", "sets", "=", "[", "c", "for", "c", "in", "df", ".", "columns", "if", "not", "c", "==", "val", "]", "if", "len", "(", "sets", ")", "==", "0", "else", "sets", "df", "=", "df", "[", "sets", "+", "[", "val", "]", "]", "if", "not", "(", "type", "(", "fixnan", ")", "==", "bool", "and", "fixnan", "==", "False", ")", ":", "df", "=", "df", ".", "fillna", "(", "fixnan", ")", "else", ":", "df", "=", "df", ".", "loc", "[", "-", "df", "[", "val", "]", ".", "isnull", "(", ")", "]", "dct", "=", "df", ".", "set_index", "(", "sets", ")", "[", "val", "]", ".", "to_dict", "(", ")", "return", "dct" ]

[ "Transform", "a", "dataframe", "into", "a", "dictionary", ";", "primarily", "used", "for", "parameter", "setting", "." ]

[ "'''\r\n Transform a dataframe into a dictionary;\r\n primarily used for parameter setting.\r\n\r\n Keyword arguments:\r\n df -- input dataframe\r\n sets -- selection of columns (default all columns except val)\r\n val -- value column (default \"value\")\r\n fixnan -- If not False: used as keyword argument for fillna;\r\n if False: drop rows with null values\r\n '''" ]

[ { "param": "df", "type": null }, { "param": "sets", "type": null }, { "param": "val", "type": null }, { "param": "fixnan", "type": null } ]

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