Datasets:

tomekkorbak

/

code_search_data-pep8

like 0

[ "def", "getdoc", "(", "obj", ")", ":", "docstring", "=", "inspect", ".", "getdoc", "(", "obj", ")", "or", "inspect", ".", "getcomments", "(", "obj", ")", "or", "''", "# Most of the time doc will only contain ascii characters, but there are", "# some docstrings that contain non-ascii characters. Not all source files", "# declare their encoding in the first line, so querying for that might not", "# yield anything, either. So assume the most commonly used", "# multi-byte file encoding (which also covers ascii). ", "try", ":", "docstring", "=", "to_text_string", "(", "docstring", ")", "except", ":", "pass", "# Doc dict keys", "doc", "=", "{", "'name'", ":", "''", ",", "'argspec'", ":", "''", ",", "'note'", ":", "''", ",", "'docstring'", ":", "docstring", "}", "if", "callable", "(", "obj", ")", ":", "try", ":", "name", "=", "obj", ".", "__name__", "except", "AttributeError", ":", "doc", "[", "'docstring'", "]", "=", "docstring", "return", "doc", "if", "inspect", ".", "ismethod", "(", "obj", ")", ":", "imclass", "=", "get_meth_class", "(", "obj", ")", "if", "get_meth_class_inst", "(", "obj", ")", "is", "not", "None", ":", "doc", "[", "'note'", "]", "=", "'Method of %s instance'", "%", "get_meth_class_inst", "(", "obj", ")", ".", "__class__", ".", "__name__", "else", ":", "doc", "[", "'note'", "]", "=", "'Unbound %s method'", "%", "imclass", ".", "__name__", "obj", "=", "get_meth_func", "(", "obj", ")", "elif", "hasattr", "(", "obj", ",", "'__module__'", ")", ":", "doc", "[", "'note'", "]", "=", "'Function of %s module'", "%", "obj", ".", "__module__", "else", ":", "doc", "[", "'note'", "]", "=", "'Function'", "doc", "[", "'name'", "]", "=", "obj", ".", "__name__", "if", "inspect", ".", "isfunction", "(", "obj", ")", ":", "if", "PY2", ":", "args", ",", "varargs", ",", "varkw", ",", "defaults", "=", "inspect", ".", "getargspec", "(", "obj", ")", "doc", "[", "'argspec'", "]", "=", "inspect", ".", "formatargspec", "(", "args", ",", "varargs", ",", "varkw", ",", "defaults", ",", "formatvalue", "=", "lambda", "o", ":", "'='", "+", "repr", "(", "o", ")", ")", "else", ":", "(", "args", ",", "varargs", ",", "varkw", ",", "defaults", ",", "kwonlyargs", ",", "kwonlydefaults", ",", "annotations", ")", "=", "inspect", ".", "getfullargspec", "(", "obj", ")", "doc", "[", "'argspec'", "]", "=", "inspect", ".", "formatargspec", "(", "args", ",", "varargs", ",", "varkw", ",", "defaults", ",", "kwonlyargs", ",", "kwonlydefaults", ",", "annotations", ",", "formatvalue", "=", "lambda", "o", ":", "'='", "+", "repr", "(", "o", ")", ")", "if", "name", "==", "'<lambda>'", ":", "doc", "[", "'name'", "]", "=", "name", "+", "' lambda '", "doc", "[", "'argspec'", "]", "=", "doc", "[", "'argspec'", "]", "[", "1", ":", "-", "1", "]", "# remove parentheses", "else", ":", "argspec", "=", "getargspecfromtext", "(", "doc", "[", "'docstring'", "]", ")", "if", "argspec", ":", "doc", "[", "'argspec'", "]", "=", "argspec", "# Many scipy and numpy docstrings begin with a function", "# signature on the first line. This ends up begin redundant", "# when we are using title and argspec to create the", "# rich text \"Definition:\" field. We'll carefully remove this", "# redundancy but only under a strict set of conditions:", "# Remove the starting charaters of the 'doc' portion *iff*", "# the non-whitespace characters on the first line ", "# match *exactly* the combined function title ", "# and argspec we determined above.", "signature", "=", "doc", "[", "'name'", "]", "+", "doc", "[", "'argspec'", "]", "docstring_blocks", "=", "doc", "[", "'docstring'", "]", ".", "split", "(", "\"\\n\\n\"", ")", "first_block", "=", "docstring_blocks", "[", "0", "]", ".", "strip", "(", ")", "if", "first_block", "==", "signature", ":", "doc", "[", "'docstring'", "]", "=", "doc", "[", "'docstring'", "]", ".", "replace", "(", "signature", ",", "''", ",", "1", ")", ".", "lstrip", "(", ")", "else", ":", "doc", "[", "'argspec'", "]", "=", "'(...)'", "# Remove self from argspec", "argspec", "=", "doc", "[", "'argspec'", "]", "doc", "[", "'argspec'", "]", "=", "argspec", ".", "replace", "(", "'(self)'", ",", "'()'", ")", ".", "replace", "(", "'(self, '", ",", "'('", ")", "return", "doc" ]

[ "Return", "text", "documentation", "from", "an", "object", ".", "This", "comes", "in", "a", "form", "of", "dictionary", "with", "four", "keys", ":" ]

[ "def", "read_table", "(", "self", ",", "table_name", ",", "index_col", "=", "None", ",", "coerce_float", "=", "True", ",", "parse_dates", "=", "None", ",", "columns", "=", "None", ",", "schema", "=", "None", ",", "chunksize", "=", "None", ")", ":", "table", "=", "SQLTable", "(", "table_name", ",", "self", ",", "index", "=", "index_col", ",", "schema", "=", "schema", ")", "return", "table", ".", "read", "(", "coerce_float", "=", "coerce_float", ",", "parse_dates", "=", "parse_dates", ",", "columns", "=", "columns", ",", "chunksize", "=", "chunksize", ")" ]

[ "Read", "SQL", "database", "table", "into", "a", "DataFrame", "." ]

[ "def", "ccube", "(", "self", ",", "*", "*", "kwargs", ")", ":", "kwargs_copy", "=", "self", ".", "base_dict", ".", "copy", "(", ")", "kwargs_copy", ".", "update", "(", "*", "*", "kwargs", ")", "kwargs_copy", "[", "'dataset'", "]", "=", "kwargs", ".", "get", "(", "'dataset'", ",", "self", ".", "dataset", "(", "*", "*", "kwargs", ")", ")", "kwargs_copy", "[", "'component'", "]", "=", "kwargs", ".", "get", "(", "'component'", ",", "self", ".", "component", "(", "*", "*", "kwargs", ")", ")", "localpath", "=", "NameFactory", ".", "ccube_format", ".", "format", "(", "*", "*", "kwargs_copy", ")", "if", "kwargs", ".", "get", "(", "'fullpath'", ",", "False", ")", ":", "return", "self", ".", "fullpath", "(", "localpath", "=", "localpath", ")", "return", "localpath" ]

[ "return", "the", "name", "of", "a", "counts", "cube", "file" ]

[ "def", "get_nt_7z_dir", "(", ")", ":", "# Python 3.x renamed the _winreg module to winreg", "try", ":", "import", "_winreg", "as", "winreg", "except", "ImportError", ":", "import", "winreg", "try", ":", "key", "=", "winreg", ".", "OpenKey", "(", "winreg", ".", "HKEY_LOCAL_MACHINE", ",", "r\"SOFTWARE\\7-Zip\"", ")", "try", ":", "return", "winreg", ".", "QueryValueEx", "(", "key", ",", "\"Path\"", ")", "[", "0", "]", "finally", ":", "winreg", ".", "CloseKey", "(", "key", ")", "except", "WindowsError", ":", "return", "\"\"" ]

[ "Return", "7", "-", "Zip", "directory", "from", "registry", "or", "an", "empty", "string", "." ]

[ "def", "infer_isinstance", "(", "callnode", ",", "context", "=", "None", ")", ":", "call", "=", "arguments", ".", "CallSite", ".", "from_call", "(", "callnode", ")", "if", "call", ".", "keyword_arguments", ":", "# isinstance doesn't support keyword arguments", "raise", "UseInferenceDefault", "(", "\"TypeError: isinstance() takes no keyword arguments\"", ")", "if", "len", "(", "call", ".", "positional_arguments", ")", "!=", "2", ":", "raise", "UseInferenceDefault", "(", "\"Expected two arguments, got {count}\"", ".", "format", "(", "count", "=", "len", "(", "call", ".", "positional_arguments", ")", ")", ")", "# The left hand argument is the obj to be checked", "obj_node", ",", "class_or_tuple_node", "=", "call", ".", "positional_arguments", "# The right hand argument is the class(es) that the given", "# obj is to be check is an instance of", "try", ":", "class_container", "=", "_class_or_tuple_to_container", "(", "class_or_tuple_node", ",", "context", "=", "context", ")", "except", "InferenceError", ":", "raise", "UseInferenceDefault", "try", ":", "isinstance_bool", "=", "helpers", ".", "object_isinstance", "(", "obj_node", ",", "class_container", ",", "context", ")", "except", "AstroidTypeError", "as", "exc", ":", "raise", "UseInferenceDefault", "(", "\"TypeError: \"", "+", "str", "(", "exc", ")", ")", "except", "MroError", "as", "exc", ":", "raise", "UseInferenceDefault", "from", "exc", "if", "isinstance_bool", "is", "util", ".", "Uninferable", ":", "raise", "UseInferenceDefault", "return", "nodes", ".", "Const", "(", "isinstance_bool", ")" ]

[ "Infer", "isinstance", "calls" ]

[ "def", "sign_out", "(", "entry", ",", "time_out", "=", "None", ",", "forgot", "=", "False", ")", ":", "# noqa", "if", "time_out", "is", "None", ":", "time_out", "=", "datetime", ".", "today", "(", ")", ".", "time", "(", ")", "if", "forgot", ":", "entry", ".", "forgot_sign_out", "=", "True", "logger", ".", "info", "(", "'{} forgot to sign out on {}.'", ".", "format", "(", "entry", ".", "user_id", ",", "entry", ".", "date", ")", ")", "else", ":", "entry", ".", "time_out", "=", "time_out", "logger", ".", "info", "(", "'{} ({}) signed out.'", ".", "format", "(", "entry", ".", "user_id", ",", "entry", ".", "user_type", ")", ")", "return", "entry" ]

[ "Sign", "out", "of", "an", "existing", "entry", "in", "the", "timesheet", ".", "If", "the", "user", "forgot", "to", "sign", "out", "flag", "the", "entry", "." ]

[ "def", "listen_until_return", "(", "self", ",", "*", "temporary_handlers", ",", "timeout", "=", "0", ")", ":", "start", "=", "time", ".", "time", "(", ")", "while", "timeout", "==", "0", "or", "time", ".", "time", "(", ")", "-", "start", "<", "timeout", ":", "res", "=", "self", ".", "listen", "(", "*", "temporary_handlers", ")", "if", "res", "is", "not", "None", ":", "return", "res" ]

[ "Calls", "listen", "repeatedly", "until", "listen", "returns", "something", "else", "than", "None", ".", "Then", "returns", "listen", "s", "result", ".", "If", "timeout", "is", "not", "zero", "listen_until_return", "stops", "after", "timeout", "seconds", "and", "returns", "None", "." ]

[ "def", "_create_connection", "(", "self", ")", ":", "db", "=", "psycopg2", ".", "connect", "(", "database", "=", "self", ".", "dbname", ",", "user", "=", "self", ".", "user", ",", "password", "=", "self", ".", "password", ",", "host", "=", "self", ".", "host", ",", "port", "=", "self", ".", "port", ")", "if", "'psycopg2.extras'", "in", "sys", ".", "modules", ":", "psycopg2", ".", "extras", ".", "register_hstore", "(", "db", ")", "return", "db" ]

[ "..", ":", "py", ":", "method", "::" ]

[ "def", "label_to_latex", "(", "text", ")", ":", "# pylint: disable=anomalous-backslash-in-string", "if", "text", "is", "None", ":", "return", "''", "out", "=", "[", "]", "x", "=", "None", "# loop over matches in reverse order and replace", "for", "m", "in", "re_latex_control", ".", "finditer", "(", "text", ")", ":", "a", ",", "b", "=", "m", ".", "span", "(", ")", "char", "=", "m", ".", "group", "(", ")", "[", "0", "]", "out", ".", "append", "(", "text", "[", "x", ":", "a", "]", ")", "out", ".", "append", "(", "r'\\%s'", "%", "char", ")", "x", "=", "b", "if", "not", "x", ":", "# no match", "return", "text", "# append prefix and return joined components", "out", ".", "append", "(", "text", "[", "b", ":", "]", ")", "return", "''", ".", "join", "(", "out", ")" ]

[ "r", "Convert", "text", "into", "a", "latex", "-", "passable", "representation", "." ]

[ "def", "alpha0_carbonate", "(", "pH", ")", ":", "alpha0_carbonate", "=", "1", "/", "(", "1", "+", "(", "K1_carbonate", "/", "invpH", "(", "pH", ")", ")", "*", "(", "1", "+", "(", "K2_carbonate", "/", "invpH", "(", "pH", ")", ")", ")", ")", "return", "alpha0_carbonate" ]

[ "Calculate", "the", "fraction", "of", "total", "carbonates", "in", "carbonic", "acid", "form", "(", "H2CO3", ")" ]

[ "def", "set_backend", "(", "self", ",", "backend", ")", ":", "self", ".", "backend", "=", "backend", "self", ".", "dagobah_id", "=", "self", ".", "backend", ".", "get_new_dagobah_id", "(", ")", "for", "job", "in", "self", ".", "jobs", ":", "job", ".", "backend", "=", "backend", "for", "task", "in", "job", ".", "tasks", ".", "values", "(", ")", ":", "task", ".", "backend", "=", "backend", "self", ".", "commit", "(", "cascade", "=", "True", ")" ]

[ "Manually", "set", "backend", "after", "construction", "." ]

[ "def", "dump_table", "(", "self", ",", "table", ",", "drop_statement", "=", "True", ")", ":", "create_statement", "=", "self", ".", "get_table_definition", "(", "table", ")", "data", "=", "self", ".", "select_all", "(", "table", ")", "statements", "=", "[", "'\\n'", ",", "sql_file_comment", "(", "''", ")", ",", "sql_file_comment", "(", "'Table structure and data dump for {0}'", ".", "format", "(", "table", ")", ")", ",", "sql_file_comment", "(", "''", ")", "]", "if", "drop_statement", ":", "statements", ".", "append", "(", "'\\nDROP TABLE IF EXISTS {0};'", ".", "format", "(", "wrap", "(", "table", ")", ")", ")", "statements", ".", "append", "(", "'{0};\\n'", ".", "format", "(", "create_statement", ")", ")", "if", "len", "(", "data", ")", ">", "0", ":", "statements", ".", "append", "(", "'{0};'", ".", "format", "(", "insert_statement", "(", "table", ",", "self", ".", "get_columns", "(", "table", ")", ",", "data", ")", ")", ")", "return", "'\\n'", ".", "join", "(", "statements", ")" ]

[ "Export", "a", "table", "structure", "and", "data", "to", "SQL", "file", "for", "backup", "or", "later", "import", "." ]

[ "def", "main", "(", ")", ":", "# process arguments", "if", "len", "(", "sys", ".", "argv", ")", "<", "3", ":", "usage", "(", ")", "rgname", "=", "sys", ".", "argv", "[", "1", "]", "vmss_name", "=", "sys", ".", "argv", "[", "2", "]", "# Load Azure app defaults", "try", ":", "with", "open", "(", "'azurermconfig.json'", ")", "as", "config_file", ":", "config_data", "=", "json", ".", "load", "(", "config_file", ")", "except", "FileNotFoundError", ":", "sys", ".", "exit", "(", "'Error: Expecting azurermconfig.json in current folder'", ")", "tenant_id", "=", "config_data", "[", "'tenantId'", "]", "app_id", "=", "config_data", "[", "'appId'", "]", "app_secret", "=", "config_data", "[", "'appSecret'", "]", "subscription_id", "=", "config_data", "[", "'subscriptionId'", "]", "access_token", "=", "azurerm", ".", "get_access_token", "(", "tenant_id", ",", "app_id", ",", "app_secret", ")", "print", "(", "'Printing VMSS details\\n'", ")", "vmssget", "=", "azurerm", ".", "get_vmss", "(", "access_token", ",", "subscription_id", ",", "rgname", ",", "vmss_name", ")", "name", "=", "vmssget", "[", "'name'", "]", "capacity", "=", "vmssget", "[", "'sku'", "]", "[", "'capacity'", "]", "location", "=", "vmssget", "[", "'location'", "]", "offer", "=", "vmssget", "[", "'properties'", "]", "[", "'virtualMachineProfile'", "]", "[", "'storageProfile'", "]", "[", "'imageReference'", "]", "[", "'offer'", "]", "sku", "=", "vmssget", "[", "'properties'", "]", "[", "'virtualMachineProfile'", "]", "[", "'storageProfile'", "]", "[", "'imageReference'", "]", "[", "'sku'", "]", "print", "(", "json", ".", "dumps", "(", "vmssget", ",", "sort_keys", "=", "False", ",", "indent", "=", "2", ",", "separators", "=", "(", "','", ",", "': '", ")", ")", ")", "print", "(", "'Name: '", "+", "name", "+", "', capacity: '", "+", "str", "(", "capacity", ")", "+", "', '", "+", "location", "+", "', '", "+", "offer", "+", "', '", "+", "sku", ")", "print", "(", "'Printing VMSS instance view'", ")", "instance_view", "=", "azurerm", ".", "get_vmss_instance_view", "(", "access_token", ",", "subscription_id", ",", "rgname", ",", "vmss_name", ")", "print", "(", "json", ".", "dumps", "(", "instance_view", ",", "sort_keys", "=", "False", ",", "indent", "=", "2", ",", "separators", "=", "(", "','", ",", "': '", ")", ")", ")", "'''\n print('Listing VMSS VMs')\n vmss_vms = azurerm.list_vmss_vms(access_token, subscription_id, rg, vmss)\n print(json.dumps(vmss_vms, sort_keys=False, indent=2, separators=(',', ': ')))\n for vm in vmss_vms['value']:\n instanceId = vm['instanceId']\n vminstance_view = azurerm.get_vmss_vm_instance_view(access_token, subscription_id, rg, vmss,\n instanceId)\n print('VM ' + str(instanceId) + ' instance view')\n print(json.dumps(vminstance_view, sort_keys=False, indent=2, separators=(',', ': ')))\n '''" ]

[ "Main", "routine", "." ]

[ "def", "reset_for_retry", "(", "self", ")", ":", "self", ".", "retries", "+=", "1", "self", ".", "last_work_item", "=", "\"\"", "self", ".", "active", "=", "True", "self", ".", "result_status", "=", "None", "self", ".", "input_finished", "=", "False", "self", ".", "counters_map", "=", "CountersMap", "(", ")", "self", ".", "slice_id", "=", "0", "self", ".", "slice_start_time", "=", "None", "self", ".", "slice_request_id", "=", "None", "self", ".", "slice_retries", "=", "0", "self", ".", "acquired_once", "=", "False" ]

[ "Reset", "self", "for", "shard", "retry", "." ]

[ "def", "change_custom_contact_var", "(", "self", ",", "contact", ",", "varname", ",", "varvalue", ")", ":", "if", "varname", ".", "upper", "(", ")", "in", "contact", ".", "customs", ":", "contact", ".", "modified_attributes", "|=", "DICT_MODATTR", "[", "\"MODATTR_CUSTOM_VARIABLE\"", "]", ".", "value", "contact", ".", "customs", "[", "varname", ".", "upper", "(", ")", "]", "=", "varvalue", "self", ".", "send_an_element", "(", "contact", ".", "get_update_status_brok", "(", ")", ")" ]

[ "Change", "custom", "contact", "variable", "Format", "of", "the", "line", "that", "triggers", "function", "call", "::" ]

[ "def", "apply_unitary", "(", "unitary_value", ":", "Any", ",", "args", ":", "ApplyUnitaryArgs", ",", "default", ":", "TDefault", "=", "RaiseTypeErrorIfNotProvided", ")", "->", "Union", "[", "np", ".", "ndarray", ",", "TDefault", "]", ":", "# Check if the specialized method is present.", "func", "=", "getattr", "(", "unitary_value", ",", "'_apply_unitary_'", ",", "None", ")", "if", "func", "is", "not", "None", ":", "result", "=", "func", "(", "args", ")", "if", "result", "is", "not", "NotImplemented", "and", "result", "is", "not", "None", ":", "return", "result", "# Fallback to using the object's _unitary_ matrix.", "matrix", "=", "unitary", "(", "unitary_value", ",", "None", ")", "if", "matrix", "is", "not", "None", ":", "# Special case for single-qubit operations.", "if", "matrix", ".", "shape", "==", "(", "2", ",", "2", ")", ":", "zero", "=", "args", ".", "subspace_index", "(", "0", ")", "one", "=", "args", ".", "subspace_index", "(", "1", ")", "return", "linalg", ".", "apply_matrix_to_slices", "(", "args", ".", "target_tensor", ",", "matrix", ",", "[", "zero", ",", "one", "]", ",", "out", "=", "args", ".", "available_buffer", ")", "# Fallback to np.einsum for the general case.", "return", "linalg", ".", "targeted_left_multiply", "(", "matrix", ".", "astype", "(", "args", ".", "target_tensor", ".", "dtype", ")", ".", "reshape", "(", "(", "2", ",", ")", "*", "(", "2", "*", "len", "(", "args", ".", "axes", ")", ")", ")", ",", "args", ".", "target_tensor", ",", "args", ".", "axes", ",", "out", "=", "args", ".", "available_buffer", ")", "# Don't know how to apply. Fallback to specified default behavior.", "if", "default", "is", "not", "RaiseTypeErrorIfNotProvided", ":", "return", "default", "raise", "TypeError", "(", "\"object of type '{}' has no _apply_unitary_ or _unitary_ methods \"", "\"(or they returned None or NotImplemented).\"", ".", "format", "(", "type", "(", "unitary_value", ")", ")", ")" ]

[ "High", "performance", "left", "-", "multiplication", "of", "a", "unitary", "effect", "onto", "a", "tensor", "." ]

[ "def", "_format_name_map", "(", "self", ",", "lonc", ",", "latc", ")", ":", "return", "'_'", ".", "join", "(", "[", "'WAC'", ",", "'GLOBAL'", "]", "+", "[", "'E'", "+", "latc", "+", "lonc", ",", "\"{0:0>3}\"", ".", "format", "(", "self", ".", "ppd", ")", "+", "'P'", "]", ")" ]

[ "Return", "the", "name", "of", "the", "map", "in", "the", "good", "format" ]

[ "def", "print_users", "(", "self", ",", "names", "=", "False", ")", ":", "users", "=", "self", ".", "get_users", "(", ")", "if", "names", ":", "users", "=", "[", "user", "[", "'name'", "]", "for", "user", "in", "users", "]", "pprint", ".", "pprint", "(", "users", ")" ]

[ "Print", "users" ]

[ "def", "PX4_update", "(", "IMU", ",", "ATT", ")", ":", "global", "px4_state", "if", "px4_state", "is", "None", ":", "px4_state", "=", "PX4_State", "(", "degrees", "(", "ATT", ".", "Roll", ")", ",", "degrees", "(", "ATT", ".", "Pitch", ")", ",", "degrees", "(", "ATT", ".", "Yaw", ")", ",", "IMU", ".", "_timestamp", ")", "gyro", "=", "Vector3", "(", "IMU", ".", "GyroX", ",", "IMU", ".", "GyroY", ",", "IMU", ".", "GyroZ", ")", "accel", "=", "Vector3", "(", "IMU", ".", "AccX", ",", "IMU", ".", "AccY", ",", "IMU", ".", "AccZ", ")", "px4_state", ".", "update", "(", "gyro", ",", "accel", ",", "IMU", ".", "_timestamp", ")", "return", "px4_state" ]

[ "implement", "full", "DCM", "using", "PX4", "native", "SD", "log", "data" ]

[ "def", "returnSplineList", "(", "dependentVar", ",", "independentVar", ",", "subsetPercentage", "=", "0.4", ",", "cycles", "=", "10", ",", "minKnotPoints", "=", "10", ",", "initialKnots", "=", "200", ",", "splineOrder", "=", "2", ",", "terminalExpansion", "=", "0.1", ")", ":", "expansions", "=", "ddict", "(", "list", ")", "expansionArea", "=", "(", "independentVar", "[", "-", "1", "]", "-", "independentVar", "[", "0", "]", ")", "*", "terminalExpansion", "#adds 100 data points at both ends of the dependent and independent array", "for", "i", "in", "range", "(", "100", ")", ":", "expansions", "[", "'indUp'", "]", ".", "append", "(", "independentVar", "[", "-", "1", "]", "+", "expansionArea", "/", "100", "*", "i", ")", "expansions", "[", "'indDown'", "]", ".", "append", "(", "independentVar", "[", "0", "]", "-", "expansionArea", "/", "100", "*", "(", "100", "-", "i", "+", "1", ")", ")", "expansions", "[", "'depUp'", "]", ".", "append", "(", "dependentVar", "[", "-", "1", "]", ")", "expansions", "[", "'depDown'", "]", ".", "append", "(", "dependentVar", "[", "0", "]", ")", "dependentVar", "=", "numpy", ".", "array", "(", "expansions", "[", "'depDown'", "]", "+", "list", "(", "dependentVar", ")", "+", "expansions", "[", "'depUp'", "]", ",", "dtype", "=", "numpy", ".", "float64", ")", "independentVar", "=", "numpy", ".", "array", "(", "expansions", "[", "'indDown'", "]", "+", "list", "(", "independentVar", ")", "+", "expansions", "[", "'indUp'", "]", ",", "dtype", "=", "numpy", ".", "float64", ")", "splineList", "=", "list", "(", ")", "for", "cycle", "in", "range", "(", "cycles", ")", ":", "subset", "=", "sorted", "(", "random", ".", "sample", "(", "range", "(", "len", "(", "dependentVar", ")", ")", ",", "int", "(", "len", "(", "dependentVar", ")", "*", "subsetPercentage", ")", ")", ")", "terminalExpansion", "dependentSubset", "=", "dependentVar", "[", "subset", "]", "independentSubset", "=", "independentVar", "[", "subset", "]", "minIndVar", "=", "independentSubset", "[", "minKnotPoints", "]", "maxIndVar", "=", "independentSubset", "[", "-", "minKnotPoints", "]", "knots", "=", "[", "float", "(", "i", ")", "*", "(", "maxIndVar", "-", "minIndVar", ")", "/", "initialKnots", "+", "minIndVar", "for", "i", "in", "range", "(", "1", ",", "initialKnots", ")", "]", "## remove knots with less then minKnotPoints data points ##", "lastKnot", "=", "knots", "[", "0", "]", "newKnotList", "=", "[", "lastKnot", "]", "for", "knotPos", "in", "range", "(", "1", ",", "len", "(", "knots", ")", ")", ":", "nextKnot", "=", "knots", "[", "knotPos", "]", "numHits", "=", "(", "len", "(", "independentSubset", "[", "(", "independentSubset", ">=", "lastKnot", ")", "&", "(", "independentSubset", "<=", "nextKnot", ")", "]", ")", ")", "if", "numHits", ">=", "minKnotPoints", ":", "newKnotList", ".", "append", "(", "nextKnot", ")", "lastKnot", "=", "nextKnot", "knots", "=", "newKnotList", "spline", "=", "LSQUnivariateSpline", "(", "independentSubset", ",", "dependentSubset", ",", "knots", ",", "k", "=", "splineOrder", ")", "splineList", ".", "append", "(", "spline", ")", "return", "splineList" ]

[ "#TODO", ":", "docstring" ]

[ "def", "_iter_module_files", "(", ")", ":", "# The list call is necessary on Python 3 in case the module", "# dictionary modifies during iteration.", "for", "module", "in", "list", "(", "sys", ".", "modules", ".", "values", "(", ")", ")", ":", "if", "module", "is", "None", ":", "continue", "filename", "=", "getattr", "(", "module", ",", "\"__file__\"", ",", "None", ")", "if", "filename", ":", "if", "os", ".", "path", ".", "isdir", "(", "filename", ")", "and", "os", ".", "path", ".", "exists", "(", "os", ".", "path", ".", "join", "(", "filename", ",", "\"__init__.py\"", ")", ")", ":", "filename", "=", "os", ".", "path", ".", "join", "(", "filename", ",", "\"__init__.py\"", ")", "old", "=", "None", "while", "not", "os", ".", "path", ".", "isfile", "(", "filename", ")", ":", "old", "=", "filename", "filename", "=", "os", ".", "path", ".", "dirname", "(", "filename", ")", "if", "filename", "==", "old", ":", "break", "else", ":", "if", "filename", "[", "-", "4", ":", "]", "in", "(", "\".pyc\"", ",", "\".pyo\"", ")", ":", "filename", "=", "filename", "[", ":", "-", "1", "]", "yield", "filename" ]

[ "This", "iterates", "over", "all", "relevant", "Python", "files", ".", "It", "goes", "through", "all", "loaded", "files", "from", "modules", "all", "files", "in", "folders", "of", "already", "loaded", "modules", "as", "well", "as", "all", "files", "reachable", "through", "a", "package", "." ]

[ "def", "CopyToDateTimeString", "(", "cls", ",", "time_elements_tuple", ",", "fraction_of_second", ")", ":", "if", "fraction_of_second", "<", "0.0", "or", "fraction_of_second", ">=", "1.0", ":", "raise", "ValueError", "(", "'Fraction of second value: {0:f} out of bounds.'", ".", "format", "(", "fraction_of_second", ")", ")", "return", "'{0:04d}-{1:02d}-{2:02d} {3:02d}:{4:02d}:{5:02d}'", ".", "format", "(", "time_elements_tuple", "[", "0", "]", ",", "time_elements_tuple", "[", "1", "]", ",", "time_elements_tuple", "[", "2", "]", ",", "time_elements_tuple", "[", "3", "]", ",", "time_elements_tuple", "[", "4", "]", ",", "time_elements_tuple", "[", "5", "]", ")" ]

[ "Copies", "the", "time", "elements", "and", "fraction", "of", "second", "to", "a", "string", "." ]

[ "def", "tri_to_am", "(", "tri", ")", ":", "# Create an empty list-of-list matrix", "lil", "=", "sprs", ".", "lil_matrix", "(", "(", "tri", ".", "npoints", ",", "tri", ".", "npoints", ")", ")", "# Scan through Delaunay triangulation to retrieve pairs", "indices", ",", "indptr", "=", "tri", ".", "vertex_neighbor_vertices", "for", "k", "in", "range", "(", "tri", ".", "npoints", ")", ":", "lil", ".", "rows", "[", "k", "]", "=", "indptr", "[", "indices", "[", "k", "]", ":", "indices", "[", "k", "+", "1", "]", "]", "# Convert to coo format", "lil", ".", "data", "=", "lil", ".", "rows", "# Just a dummy array to make things work properly", "coo", "=", "lil", ".", "tocoo", "(", ")", "# Set weights to 1's", "coo", ".", "data", "=", "sp", ".", "ones_like", "(", "coo", ".", "data", ")", "# Remove diagonal, and convert to csr remove duplicates", "am", "=", "sp", ".", "sparse", ".", "triu", "(", "A", "=", "coo", ",", "k", "=", "1", ",", "format", "=", "'csr'", ")", "# The convert back to COO and return", "am", "=", "am", ".", "tocoo", "(", ")", "return", "am" ]

[ "r", "Given", "a", "Delaunay", "Triangulation", "object", "from", "Scipy", "s", "spatial", "module", "converts", "to", "a", "sparse", "adjacency", "matrix", "network", "representation", "." ]

[ "def", "plot_dry_adiabats", "(", "self", ",", "p", "=", "None", ",", "theta", "=", "None", ",", "*", "*", "kwargs", ")", ":", "for", "artist", "in", "self", ".", "_dry_adiabats", ":", "artist", ".", "remove", "(", ")", "self", ".", "_dry_adiabats", "=", "[", "]", "# Determine set of starting temps if necessary", "if", "theta", "is", "None", ":", "xmin", ",", "xmax", "=", "self", ".", "get_xlim", "(", ")", "theta", "=", "np", ".", "arange", "(", "xmin", ",", "xmax", "+", "201", ",", "10", ")", "# Get pressure levels based on ylims if necessary", "if", "p", "is", "None", ":", "p", "=", "np", ".", "linspace", "(", "*", "self", ".", "get_ylim", "(", ")", ")", "# Assemble into data for plotting", "t", "=", "calculate", "(", "'T'", ",", "theta", "=", "theta", "[", ":", ",", "None", "]", ",", "p", "=", "p", ",", "p_units", "=", "'hPa'", ",", "T_units", "=", "'degC'", ",", "theta_units", "=", "'degC'", ")", "linedata", "=", "[", "np", ".", "vstack", "(", "(", "ti", ",", "p", ")", ")", ".", "T", "for", "ti", "in", "t", "]", "# Add to plot", "kwargs", ".", "setdefault", "(", "'clip_on'", ",", "True", ")", "kwargs", ".", "setdefault", "(", "'colors'", ",", "'#A65300'", ")", "kwargs", ".", "setdefault", "(", "'linestyles'", ",", "'-'", ")", "kwargs", ".", "setdefault", "(", "'alpha'", ",", "1", ")", "kwargs", ".", "setdefault", "(", "'linewidth'", ",", "0.5", ")", "kwargs", ".", "setdefault", "(", "'zorder'", ",", "1.1", ")", "collection", "=", "LineCollection", "(", "linedata", ",", "*", "*", "kwargs", ")", "self", ".", "_dry_adiabats", ".", "append", "(", "collection", ")", "self", ".", "add_collection", "(", "collection", ")", "theta", "=", "theta", ".", "flatten", "(", ")", "T_label", "=", "calculate", "(", "'T'", ",", "p", "=", "140", ",", "p_units", "=", "'hPa'", ",", "theta", "=", "theta", ",", "T_units", "=", "'degC'", ",", "theta_units", "=", "'degC'", ")", "for", "i", "in", "range", "(", "len", "(", "theta", ")", ")", ":", "text", "=", "self", ".", "text", "(", "T_label", "[", "i", "]", ",", "140", ",", "'{:.0f}'", ".", "format", "(", "theta", "[", "i", "]", ")", ",", "fontsize", "=", "8", ",", "ha", "=", "'left'", ",", "va", "=", "'center'", ",", "rotation", "=", "-", "60", ",", "color", "=", "'#A65300'", ",", "bbox", "=", "{", "'facecolor'", ":", "'w'", ",", "'edgecolor'", ":", "'w'", ",", "'alpha'", ":", "0", ",", "}", ",", "zorder", "=", "1.2", ")", "text", ".", "set_clip_on", "(", "True", ")", "self", ".", "_dry_adiabats", ".", "append", "(", "text", ")" ]

[ "r", "Plot", "dry", "adiabats", "." ]

[ "def", "has_output", "(", "state", ",", "text", ",", "incorrect_msg", "=", "\"The checker expected to find {{'' if fixed else 'the pattern '}}`{{text}}` in the output of your command.\"", ",", "fixed", "=", "False", ",", "strip_ansi", "=", "True", ")", ":", "stu_output", "=", "state", ".", "student_result", "if", "strip_ansi", ":", "stu_output", "=", "_strip_ansi", "(", "stu_output", ")", "# either simple text matching or regex test", "res", "=", "text", "in", "stu_output", "if", "fixed", "else", "re", ".", "search", "(", "text", ",", "stu_output", ")", "if", "not", "res", ":", "_msg", "=", "state", ".", "build_message", "(", "incorrect_msg", ",", "fmt_kwargs", "=", "{", "'text'", ":", "text", ",", "'fixed'", ":", "fixed", "}", ")", "state", ".", "do_test", "(", "_msg", ")", "return", "state" ]

[ "Check", "whether", "student", "output", "contains", "specific", "text", "." ]

[ "def", "plot_oneD", "(", "dataset", ",", "vars", ",", "filename", ",", "bins", "=", "60", ")", ":", "n", "=", "len", "(", "vars", ")", "fig", ",", "axes", "=", "plt", ".", "subplots", "(", "nrows", "=", "n", ",", "ncols", "=", "1", ",", "sharex", "=", "False", ",", "sharey", "=", "False", ")", "for", "i", ",", "x", "in", "enumerate", "(", "vars", ")", ":", "ax", "=", "axes", "[", "i", "]", "P", "=", "posterior", ".", "oneD", "(", "dataset", "+", "'.h5'", ",", "x", ",", "limits", "=", "limits", "(", "x", ")", ",", "bins", "=", "bins", ")", "P", ".", "plot", "(", "ax", ")", "ax", ".", "set_xlabel", "(", "labels", "(", "x", ")", ")", "ax", ".", "set_yticklabels", "(", "[", "]", ")", "fig", ".", "set_size_inches", "(", "4", ",", "4", "*", "n", ")", "fig", ".", "savefig", "(", "filename", ",", "dpi", "=", "200", ",", "bbox_inches", "=", "'tight'", ")", "plt", ".", "close", "(", "fig", ")" ]

[ "Plot", "1D", "marginalised", "posteriors", "for", "the", "vars", "of", "interest", "." ]

[ "def", "get_all_operators", "(", "self", ")", ":", "if", "len", "(", "self", ".", "operators", ")", ">=", "len", "(", "OperatorStatisticNames", ")", ":", "return", "self", ".", "operators", "result", "=", "yield", "from", "self", ".", "load_all_operators", "(", ")", "return", "result" ]

[ "|coro|" ]

[ "def", "toggle_scan", "(", "self", ",", "enable", ",", "filter_duplicates", "=", "False", ")", ":", "command", "=", "struct", ".", "pack", "(", "\">BB\"", ",", "enable", ",", "filter_duplicates", ")", "self", ".", "bluez", ".", "hci_send_cmd", "(", "self", ".", "socket", ",", "OGF_LE_CTL", ",", "OCF_LE_SET_SCAN_ENABLE", ",", "command", ")" ]

[ "Enables", "or", "disables", "BLE", "scanning" ]

[ "def", "get_assignable_repository_ids", "(", "self", ",", "repository_id", ")", ":", "# Implemented from template for", "# osid.resource.ResourceBinAssignmentSession.get_assignable_bin_ids", "# This will likely be overridden by an authorization adapter", "mgr", "=", "self", ".", "_get_provider_manager", "(", "'REPOSITORY'", ",", "local", "=", "True", ")", "lookup_session", "=", "mgr", ".", "get_repository_lookup_session", "(", "proxy", "=", "self", ".", "_proxy", ")", "repositories", "=", "lookup_session", ".", "get_repositories", "(", ")", "id_list", "=", "[", "]", "for", "repository", "in", "repositories", ":", "id_list", ".", "append", "(", "repository", ".", "get_id", "(", ")", ")", "return", "IdList", "(", "id_list", ")" ]

[ "Gets", "a", "list", "of", "repositories", "including", "and", "under", "the", "given", "repository", "node", "in", "which", "any", "asset", "can", "be", "assigned", "." ]

[ "def", "_find_cont_fitfunc", "(", "fluxes", ",", "ivars", ",", "contmask", ",", "deg", ",", "ffunc", ",", "n_proc", "=", "1", ")", ":", "nstars", "=", "fluxes", ".", "shape", "[", "0", "]", "npixels", "=", "fluxes", ".", "shape", "[", "1", "]", "cont", "=", "np", ".", "zeros", "(", "fluxes", ".", "shape", ")", "if", "n_proc", "==", "1", ":", "for", "jj", "in", "range", "(", "nstars", ")", ":", "flux", "=", "fluxes", "[", "jj", ",", ":", "]", "ivar", "=", "ivars", "[", "jj", ",", ":", "]", "pix", "=", "np", ".", "arange", "(", "0", ",", "npixels", ")", "y", "=", "flux", "[", "contmask", "]", "x", "=", "pix", "[", "contmask", "]", "yivar", "=", "ivar", "[", "contmask", "]", "yivar", "[", "yivar", "==", "0", "]", "=", "SMALL", "**", "2", "if", "ffunc", "==", "\"sinusoid\"", ":", "p0", "=", "np", ".", "ones", "(", "deg", "*", "2", ")", "# one for cos, one for sin", "L", "=", "max", "(", "x", ")", "-", "min", "(", "x", ")", "pcont_func", "=", "_partial_func", "(", "_sinusoid", ",", "L", "=", "L", ",", "y", "=", "flux", ")", "popt", ",", "pcov", "=", "opt", ".", "curve_fit", "(", "pcont_func", ",", "x", ",", "y", ",", "p0", "=", "p0", ",", "sigma", "=", "1.", "/", "np", ".", "sqrt", "(", "yivar", ")", ")", "elif", "ffunc", "==", "\"chebyshev\"", ":", "fit", "=", "np", ".", "polynomial", ".", "chebyshev", ".", "Chebyshev", ".", "fit", "(", "x", "=", "x", ",", "y", "=", "y", ",", "w", "=", "yivar", ",", "deg", "=", "deg", ")", "for", "element", "in", "pix", ":", "if", "ffunc", "==", "\"sinusoid\"", ":", "cont", "[", "jj", ",", "element", "]", "=", "_sinusoid", "(", "element", ",", "popt", ",", "L", "=", "L", ",", "y", "=", "flux", ")", "elif", "ffunc", "==", "\"chebyshev\"", ":", "cont", "[", "jj", ",", "element", "]", "=", "fit", "(", "element", ")", "else", ":", "# start mp.Pool", "pool", "=", "mp", ".", "Pool", "(", "processes", "=", "n_proc", ")", "mp_results", "=", "[", "]", "for", "i", "in", "xrange", "(", "nstars", ")", ":", "mp_results", ".", "append", "(", "pool", ".", "apply_async", "(", "_find_cont_fitfunc", ",", "(", "fluxes", "[", "i", ",", ":", "]", ".", "reshape", "(", "(", "1", ",", "-", "1", ")", ")", ",", "ivars", "[", "i", ",", ":", "]", ".", "reshape", "(", "(", "1", ",", "-", "1", ")", ")", ",", "contmask", "[", ":", "]", ")", ",", "{", "'deg'", ":", "deg", ",", "'ffunc'", ":", "ffunc", "}", ")", ")", "# close mp.Pool", "pool", ".", "close", "(", ")", "pool", ".", "join", "(", ")", "cont", "=", "np", ".", "array", "(", "[", "mp_results", "[", "i", "]", ".", "get", "(", ")", ".", "flatten", "(", ")", "for", "i", "in", "xrange", "(", "nstars", ")", "]", ")", "return", "cont" ]

[ "Fit", "a", "continuum", "to", "a", "continuum", "pixels", "in", "a", "segment", "of", "spectra" ]

[ "def", "get_properties", "(", "obj", ")", ":", "if", "hasattr", "(", "obj", ",", "'keys'", ")", ":", "return", "obj", ".", "keys", "(", ")", "elif", "hasattr", "(", "obj", ",", "'__dict__'", ")", ":", "return", "obj", ".", "__dict__", ".", "keys", "(", ")", "return", "[", "]" ]

[ "Returns", "a", "list", "of", "properties", "for", "L", "{", "obj", "}" ]

[ "def", "search_term", "(", "self", ")", ":", "search_term", "=", "_c", "(", "self", ".", "request", ".", "get", "(", "\"searchTerm\"", ",", "\"\"", ")", ")", "return", "search_term", ".", "lower", "(", ")", ".", "strip", "(", ")" ]

[ "Returns", "the", "search", "term" ]

[ "def", "delete_group", "(", "self", ",", "group_id", ")", ":", "route_values", "=", "{", "}", "if", "group_id", "is", "not", "None", ":", "route_values", "[", "'groupId'", "]", "=", "self", ".", "_serialize", ".", "url", "(", "'group_id'", ",", "group_id", ",", "'str'", ")", "self", ".", "_send", "(", "http_method", "=", "'DELETE'", ",", "location_id", "=", "'5966283b-4196-4d57-9211-1b68f41ec1c2'", ",", "version", "=", "'5.0'", ",", "route_values", "=", "route_values", ")" ]

[ "DeleteGroup", ".", ":", "param", "str", "group_id", ":" ]

[ "def", "_cas_4", "(", "self", ")", ":", "lonc_left", "=", "self", ".", "_format_lon", "(", "self", ".", "lonm", ")", "lonc_right", "=", "self", ".", "_format_lon", "(", "self", ".", "lonM", ")", "latc_top", "=", "self", ".", "_format_lat", "(", "self", ".", "latM", ")", "latc_bot", "=", "self", ".", "_format_lat", "(", "self", ".", "latm", ")", "img_name_00", "=", "self", ".", "_format_name_map", "(", "lonc_left", ",", "latc_top", ")", "img_00", "=", "BinaryTable", "(", "img_name_00", ",", "self", ".", "path_pdsfiles", ")", "X_00", ",", "Y_00", ",", "Z_00", "=", "img_00", ".", "extract_grid", "(", "self", ".", "lonm", ",", "float", "(", "img_00", ".", "EASTERNMOST_LONGITUDE", ")", ",", "float", "(", "img_00", ".", "MINIMUM_LATITUDE", ")", ",", "self", ".", "latM", ")", "img_name_01", "=", "self", ".", "_format_name_map", "(", "lonc_right", ",", "latc_top", ")", "img_01", "=", "BinaryTable", "(", "img_name_01", ",", "self", ".", "path_pdsfiles", ")", "X_01", ",", "Y_01", ",", "Z_01", "=", "img_01", ".", "extract_grid", "(", "float", "(", "img_01", ".", "WESTERNMOST_LONGITUDE", ")", ",", "self", ".", "lonM", ",", "float", "(", "img_01", ".", "MINIMUM_LATITUDE", ")", ",", "self", ".", "latM", ")", "img_name_10", "=", "self", ".", "_format_name_map", "(", "lonc_left", ",", "latc_bot", ")", "img_10", "=", "BinaryTable", "(", "img_name_10", ",", "self", ".", "path_pdsfiles", ")", "X_10", ",", "Y_10", ",", "Z_10", "=", "img_10", ".", "extract_grid", "(", "self", ".", "lonm", ",", "float", "(", "img_10", ".", "EASTERNMOST_LONGITUDE", ")", ",", "self", ".", "latm", ",", "float", "(", "img_10", ".", "MAXIMUM_LATITUDE", ")", ")", "img_name_11", "=", "self", ".", "_format_name_map", "(", "lonc_right", ",", "latc_bot", ")", "img_11", "=", "BinaryTable", "(", "img_name_11", ",", "self", ".", "path_pdsfiles", ")", "X_11", ",", "Y_11", ",", "Z_11", "=", "img_11", ".", "extract_grid", "(", "float", "(", "img_11", ".", "WESTERNMOST_LONGITUDE", ")", ",", "self", ".", "lonM", ",", "self", ".", "latm", ",", "float", "(", "img_11", ".", "MAXIMUM_LATITUDE", ")", ")", "X_new_top", "=", "np", ".", "hstack", "(", "(", "X_00", ",", "X_01", ")", ")", "X_new_bot", "=", "np", ".", "hstack", "(", "(", "X_10", ",", "X_11", ")", ")", "X_new", "=", "np", ".", "vstack", "(", "(", "X_new_top", ",", "X_new_bot", ")", ")", "Y_new_top", "=", "np", ".", "hstack", "(", "(", "Y_00", ",", "Y_01", ")", ")", "Y_new_bot", "=", "np", ".", "hstack", "(", "(", "Y_10", ",", "Y_11", ")", ")", "Y_new", "=", "np", ".", "vstack", "(", "(", "Y_new_top", ",", "Y_new_bot", ")", ")", "Z_new_top", "=", "np", ".", "hstack", "(", "(", "Z_00", ",", "Z_01", ")", ")", "Z_new_bot", "=", "np", ".", "hstack", "(", "(", "Z_10", ",", "Z_11", ")", ")", "Z_new", "=", "np", ".", "vstack", "(", "(", "Z_new_top", ",", "Z_new_bot", ")", ")", "return", "X_new", ",", "Y_new", ",", "Z_new" ]

[ "Longitude", "/", "Lagitude", "overlap", "(", "4", "images", ")" ]

[ "def", "clr", "(", "args", ")", ":", "p", "=", "OptionParser", "(", "clr", ".", "__doc__", ")", "p", ".", "set_bedpe", "(", ")", "opts", ",", "args", "=", "p", ".", "parse_args", "(", "args", ")", "if", "len", "(", "args", ")", "!=", "2", ":", "sys", ".", "exit", "(", "not", "p", ".", "print_help", "(", ")", ")", "bedpe", ",", "ref", "=", "args", "if", "bedpe", ".", "endswith", "(", "\".bam\"", ")", ":", "bedpefile", "=", "bedpe", ".", "replace", "(", "\".bam\"", ",", "\".bedpe\"", ")", "if", "need_update", "(", "bedpe", ",", "bedpefile", ")", ":", "cmd", "=", "\"bamToBed -bedpe -i {0}\"", ".", "format", "(", "bedpe", ")", "sh", "(", "cmd", ",", "outfile", "=", "bedpefile", ")", "bedpe", "=", "bedpefile", "filtered", "=", "bedpe", "+", "\".filtered\"", "if", "need_update", "(", "bedpe", ",", "filtered", ")", ":", "filter_bedpe", "(", "bedpe", ",", "filtered", ",", "ref", ",", "rc", "=", "opts", ".", "rc", ",", "minlen", "=", "opts", ".", "minlen", ",", "maxlen", "=", "opts", ".", "maxlen", ")", "rmdup", "=", "filtered", "+", "\".sorted.rmdup\"", "if", "need_update", "(", "filtered", ",", "rmdup", ")", ":", "rmdup_bedpe", "(", "filtered", ",", "rmdup", ",", "dupwiggle", "=", "opts", ".", "dup", ")", "converted", "=", "rmdup", "+", "\".converted\"", "if", "need_update", "(", "rmdup", ",", "converted", ")", ":", "fp", "=", "open", "(", "rmdup", ")", "fw", "=", "open", "(", "converted", ",", "\"w\"", ")", "for", "row", "in", "fp", ":", "r", "=", "BedpeLine", "(", "row", ")", "print", "(", "r", ".", "bedline", ",", "file", "=", "fw", ")", "fw", ".", "close", "(", ")", "merged", "=", "converted", "+", "\".merge.bed\"", "if", "need_update", "(", "converted", ",", "merged", ")", ":", "mergeBed", "(", "converted", ")" ]

[ "%prog", "clr", "[", "bamfile|bedpefile", "]", "ref", ".", "fasta" ]

[ "def", "post", "(", "self", ",", "request", ",", "*", "args", ",", "*", "*", "kwargs", ")", ":", "kwargs", "[", "'pk'", "]", "=", "request", ".", "user", ".", "id", "self", ".", "kwargs", "[", "'pk'", "]", "=", "request", ".", "user", ".", "id", "return", "super", "(", ")", ".", "post", "(", "request", ",", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "Add", "user", "id", "to", "kwargs" ]

[ "def", "horizontal_infrared_radiation_intensity", "(", "self", ",", "value", "=", "9999.0", ")", ":", "if", "value", "is", "not", "None", ":", "try", ":", "value", "=", "float", "(", "value", ")", "except", "ValueError", ":", "raise", "ValueError", "(", "'value {} need to be of type float '", "'for field `horizontal_infrared_radiation_intensity`'", ".", "format", "(", "value", ")", ")", "if", "value", "<", "0.0", ":", "raise", "ValueError", "(", "'value need to be greater or equal 0.0 '", "'for field `horizontal_infrared_radiation_intensity`'", ")", "self", ".", "_horizontal_infrared_radiation_intensity", "=", "value" ]

[ "Corresponds", "to", "IDD", "Field", "horizontal_infrared_radiation_intensity" ]

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

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

[ "def", "preview", "(", "self", ",", "limit", "=", "None", ",", "width", "=", "None", ")", ":", "heading", "=", "self", ".", "heading", "rel", "=", "self", ".", "proj", "(", "*", "heading", ".", "non_blobs", ")", "if", "limit", "is", "None", ":", "limit", "=", "config", "[", "'display.limit'", "]", "if", "width", "is", "None", ":", "width", "=", "config", "[", "'display.width'", "]", "tuples", "=", "rel", ".", "fetch", "(", "limit", "=", "limit", "+", "1", ",", "format", "=", "\"array\"", ")", "has_more", "=", "len", "(", "tuples", ")", ">", "limit", "tuples", "=", "tuples", "[", ":", "limit", "]", "columns", "=", "heading", ".", "names", "widths", "=", "{", "f", ":", "min", "(", "max", "(", "[", "len", "(", "f", ")", "]", "+", "[", "len", "(", "str", "(", "e", ")", ")", "for", "e", "in", "tuples", "[", "f", "]", "]", "if", "f", "in", "tuples", ".", "dtype", ".", "names", "else", "[", "len", "(", "'=BLOB='", ")", "]", ")", "+", "4", ",", "width", ")", "for", "f", "in", "columns", "}", "templates", "=", "{", "f", ":", "'%%-%d.%ds'", "%", "(", "widths", "[", "f", "]", ",", "widths", "[", "f", "]", ")", "for", "f", "in", "columns", "}", "return", "(", "' '", ".", "join", "(", "[", "templates", "[", "f", "]", "%", "(", "'*'", "+", "f", "if", "f", "in", "rel", ".", "primary_key", "else", "f", ")", "for", "f", "in", "columns", "]", ")", "+", "'\\n'", "+", "' '", ".", "join", "(", "[", "'+'", "+", "'-'", "*", "(", "widths", "[", "column", "]", "-", "2", ")", "+", "'+'", "for", "column", "in", "columns", "]", ")", "+", "'\\n'", "+", "'\\n'", ".", "join", "(", "' '", ".", "join", "(", "templates", "[", "f", "]", "%", "(", "tup", "[", "f", "]", "if", "f", "in", "tup", ".", "dtype", ".", "names", "else", "'=BLOB='", ")", "for", "f", "in", "columns", ")", "for", "tup", "in", "tuples", ")", "+", "(", "'\\n ...\\n'", "if", "has_more", "else", "'\\n'", ")", "+", "(", "' (Total: %d)\\n'", "%", "len", "(", "rel", ")", "if", "config", "[", "'display.show_tuple_count'", "]", "else", "''", ")", ")" ]

[ "returns", "a", "preview", "of", "the", "contents", "of", "the", "query", "." ]

[ "def", "_compile_batch_fluents", "(", "self", ",", "fluents", ":", "List", "[", "Tuple", "[", "str", ",", "TensorFluent", "]", "]", ",", "batch_size", ":", "int", ")", "->", "Sequence", "[", "tf", ".", "Tensor", "]", ":", "batch_fluents", "=", "[", "]", "with", "self", ".", "graph", ".", "as_default", "(", ")", ":", "for", "name", ",", "fluent", "in", "fluents", ":", "name_scope", "=", "utils", ".", "identifier", "(", "name", ")", "with", "tf", ".", "name_scope", "(", "name_scope", ")", ":", "t", "=", "tf", ".", "stack", "(", "[", "fluent", ".", "tensor", "]", "*", "batch_size", ")", "batch_fluents", ".", "append", "(", "t", ")", "return", "tuple", "(", "batch_fluents", ")" ]

[ "Compiles", "fluents", "into", "tensors", "with", "given", "batch_size", "." ]

[ "def", "compute_etag", "(", "self", ")", "->", "Optional", "[", "str", "]", ":", "hasher", "=", "hashlib", ".", "sha1", "(", ")", "for", "part", "in", "self", ".", "_write_buffer", ":", "hasher", ".", "update", "(", "part", ")", "return", "'\"%s\"'", "%", "hasher", ".", "hexdigest", "(", ")" ]

[ "Computes", "the", "etag", "header", "to", "be", "used", "for", "this", "request", "." ]

[ "def", "main", "(", "args", ")", ":", "if", "args", ".", "blacklisted_submissions", ":", "logging", ".", "warning", "(", "'BLACKLISTED SUBMISSIONS: %s'", ",", "args", ".", "blacklisted_submissions", ")", "if", "args", ".", "limited_dataset", ":", "logging", ".", "info", "(", "'Using limited dataset: 3 batches * 10 images'", ")", "max_dataset_num_images", "=", "30", "batch_size", "=", "10", "else", ":", "logging", ".", "info", "(", "'Using full dataset. Batch size: %d'", ",", "DEFAULT_BATCH_SIZE", ")", "max_dataset_num_images", "=", "None", "batch_size", "=", "DEFAULT_BATCH_SIZE", "random", ".", "seed", "(", ")", "print", "(", "'\\nRound: {0}\\n'", ".", "format", "(", "args", ".", "round_name", ")", ")", "eval_master", "=", "EvaluationMaster", "(", "storage_client", "=", "eval_lib", ".", "CompetitionStorageClient", "(", "args", ".", "project_id", ",", "args", ".", "storage_bucket", ")", ",", "datastore_client", "=", "eval_lib", ".", "CompetitionDatastoreClient", "(", "args", ".", "project_id", ",", "args", ".", "round_name", ")", ",", "round_name", "=", "args", ".", "round_name", ",", "dataset_name", "=", "args", ".", "dataset_name", ",", "blacklisted_submissions", "=", "args", ".", "blacklisted_submissions", ",", "results_dir", "=", "args", ".", "results_dir", ",", "num_defense_shards", "=", "args", ".", "num_defense_shards", ",", "verbose", "=", "args", ".", "verbose", ",", "batch_size", "=", "batch_size", ",", "max_dataset_num_images", "=", "max_dataset_num_images", ")", "if", "args", ".", "command", "==", "'attack'", ":", "eval_master", ".", "prepare_attacks", "(", ")", "elif", "args", ".", "command", "==", "'defense'", ":", "eval_master", ".", "prepare_defenses", "(", ")", "elif", "args", ".", "command", "==", "'cleanup_defenses'", ":", "eval_master", ".", "cleanup_defenses", "(", ")", "elif", "args", ".", "command", "==", "'results'", ":", "eval_master", ".", "compute_results", "(", ")", "elif", "args", ".", "command", "==", "'status'", ":", "eval_master", ".", "show_status", "(", ")", "elif", "args", ".", "command", "==", "'cleanup_datastore'", ":", "eval_master", ".", "cleanup_datastore", "(", ")", "elif", "args", ".", "command", "==", "'cleanup_failed_attacks'", ":", "eval_master", ".", "cleanup_failed_attacks", "(", ")", "elif", "args", ".", "command", "==", "'cleanup_attacks_with_zero_images'", ":", "eval_master", ".", "cleanup_attacks_with_zero_images", "(", ")", "else", ":", "print", "(", "'Invalid command: '", ",", "args", ".", "command", ")", "print", "(", "''", ")", "print", "(", "USAGE", ")" ]

[ "Main", "function", "which", "runs", "master", "." ]

[ "def", "start", "(", "self", ")", ":", "self", ".", "_events_to_write", "=", "[", "]", "self", ".", "_new_contracts_to_write", "=", "[", "]", "@", "events", ".", "on", "(", "SmartContractEvent", ".", "CONTRACT_CREATED", ")", "@", "events", ".", "on", "(", "SmartContractEvent", ".", "CONTRACT_MIGRATED", ")", "def", "call_on_success_event", "(", "sc_event", ":", "SmartContractEvent", ")", ":", "self", ".", "on_smart_contract_created", "(", "sc_event", ")", "@", "events", ".", "on", "(", "SmartContractEvent", ".", "RUNTIME_NOTIFY", ")", "def", "call_on_event", "(", "sc_event", ":", "NotifyEvent", ")", ":", "self", ".", "on_smart_contract_event", "(", "sc_event", ")", "Blockchain", ".", "Default", "(", ")", ".", "PersistCompleted", ".", "on_change", "+=", "self", ".", "on_persist_completed" ]

[ "Handle", "EventHub", "events", "for", "SmartContract", "decorators" ]

[ "def", "_check_arguments", "(", "symbol", ")", ":", "arg_set", "=", "set", "(", ")", "arg_names", "=", "symbol", ".", "list_arguments", "(", ")", "for", "name", "in", "arg_names", ":", "if", "name", "in", "arg_set", ":", "raise", "ValueError", "(", "(", "'Find duplicated argument name \\\"%s\\\", '", "+", "'please make the weight name non-duplicated(using name arguments), '", "+", "'arguments are %s'", ")", "%", "(", "name", ",", "str", "(", "arg_names", ")", ")", ")", "arg_set", ".", "add", "(", "name", ")", "aux_set", "=", "set", "(", ")", "aux_names", "=", "symbol", ".", "list_auxiliary_states", "(", ")", "for", "name", "in", "aux_names", ":", "if", "name", "in", "aux_set", ":", "raise", "ValueError", "(", "(", "'Find duplicated auxiliary param name \\\"%s\\\", '", "+", "'please make the weight name non-duplicated(using name arguments), '", "+", "'arguments are %s, auxiliary params are %s'", ")", "%", "(", "name", ",", "str", "(", "arg_names", ")", ",", "str", "(", "aux_names", ")", ")", ")", "aux_set", ".", "add", "(", "name", ")" ]

[ "Check", "the", "argument", "names", "of", "symbol", ".", "This", "function", "checks", "the", "duplication", "of", "arguments", "in", "Symbol", ".", "The", "check", "is", "done", "for", "feedforward", "net", "for", "now", "." ]

[ "def", "_find_pair", "(", "self", ",", "protocol", ",", "remote_candidate", ")", ":", "for", "pair", "in", "self", ".", "_check_list", ":", "if", "(", "pair", ".", "protocol", "==", "protocol", "and", "pair", ".", "remote_candidate", "==", "remote_candidate", ")", ":", "return", "pair", "return", "None" ]

[ "Find", "a", "candidate", "pair", "in", "the", "check", "list", "." ]

[ "async", "def", "set_chat_sticker_set", "(", "self", ",", "chat_id", ":", "typing", ".", "Union", "[", "base", ".", "Integer", ",", "base", ".", "String", "]", ",", "sticker_set_name", ":", "base", ".", "String", ")", "->", "base", ".", "Boolean", ":", "payload", "=", "generate_payload", "(", "*", "*", "locals", "(", ")", ")", "result", "=", "await", "self", ".", "request", "(", "api", ".", "Methods", ".", "SET_CHAT_STICKER_SET", ",", "payload", ")", "return", "result" ]

[ "Use", "this", "method", "to", "set", "a", "new", "group", "sticker", "set", "for", "a", "supergroup", ".", "The", "bot", "must", "be", "an", "administrator", "in", "the", "chat", "for", "this", "to", "work", "and", "must", "have", "the", "appropriate", "admin", "rights", "." ]

[ "def", "summarize", "(", "self", ",", "text", ",", "length", "=", "5", ",", "weighting", "=", "'frequency'", ",", "norm", "=", "None", ")", ":", "text", "=", "self", ".", "_parse_input", "(", "text", ")", "sentences", ",", "unprocessed_sentences", "=", "self", ".", "_tokenizer", ".", "tokenize_sentences", "(", "text", ")", "length", "=", "self", ".", "_parse_summary_length", "(", "length", ",", "len", "(", "sentences", ")", ")", "if", "length", "==", "len", "(", "sentences", ")", ":", "return", "unprocessed_sentences", "# Compute the word frequency matrix. If norm is set to 'l1' or 'l2' then words are normalized", "# by the length of their associated sentences (such that each vector of sentence terms sums to 1).", "word_matrix", "=", "self", ".", "_compute_matrix", "(", "sentences", ",", "weighting", "=", "weighting", ",", "norm", "=", "norm", ")", "# Build the similarity graph by calculating the number of overlapping words between all", "# combinations of sentences.", "similarity_matrix", "=", "(", "word_matrix", "*", "word_matrix", ".", "T", ")", "similarity_graph", "=", "networkx", ".", "from_scipy_sparse_matrix", "(", "similarity_matrix", ")", "scores", "=", "networkx", ".", "pagerank", "(", "similarity_graph", ")", "ranked_sentences", "=", "sorted", "(", "(", "(", "score", ",", "ndx", ")", "for", "ndx", ",", "score", "in", "scores", ".", "items", "(", ")", ")", ",", "reverse", "=", "True", ")", "top_sentences", "=", "[", "ranked_sentences", "[", "i", "]", "[", "1", "]", "for", "i", "in", "range", "(", "length", ")", "]", "top_sentences", ".", "sort", "(", ")", "return", "[", "unprocessed_sentences", "[", "i", "]", "for", "i", "in", "top_sentences", "]" ]

[ "Implements", "the", "TextRank", "summarization", "algorithm", "which", "follows", "closely", "to", "the", "PageRank", "algorithm", "for", "ranking", "web", "pages", "." ]

[ "def", "unicorn_edit", "(", "path", ",", "*", "*", "kwargs", ")", ":", "ctx", "=", "Context", "(", "*", "*", "kwargs", ")", "ctx", ".", "timeout", "=", "None", "ctx", ".", "execute_action", "(", "'unicorn:edit'", ",", "*", "*", "{", "'unicorn'", ":", "ctx", ".", "repo", ".", "create_secure_service", "(", "'unicorn'", ")", ",", "'path'", ":", "path", ",", "}", ")" ]

[ "Edit", "Unicorn", "node", "interactively", "." ]

[ "def", "set_global_permissions", "(", "self", ",", "global_permissions", ")", ":", "content", "=", "self", ".", "_serialize", ".", "body", "(", "global_permissions", ",", "'[GlobalPermission]'", ")", "response", "=", "self", ".", "_send", "(", "http_method", "=", "'PATCH'", ",", "location_id", "=", "'a74419ef-b477-43df-8758-3cd1cd5f56c6'", ",", "version", "=", "'5.0-preview.1'", ",", "content", "=", "content", ")", "return", "self", ".", "_deserialize", "(", "'[GlobalPermission]'", ",", "self", ".", "_unwrap_collection", "(", "response", ")", ")" ]

[ "SetGlobalPermissions", ".", "[", "Preview", "API", "]", "Set", "service", "-", "wide", "permissions", "that", "govern", "feed", "creation", ".", ":", "param", "[", "GlobalPermission", "]", "global_permissions", ":", "New", "permissions", "for", "the", "organization", ".", ":", "rtype", ":", "[", "GlobalPermission", "]" ]

[ "def", "refresh", "(", "self", ")", ":", "font", "=", "self", ".", "current_font", "# refresh btn_bold", "self", ".", "btn_bold", ".", "blockSignals", "(", "True", ")", "self", ".", "btn_bold", ".", "setChecked", "(", "font", ".", "weight", "(", ")", ">", "50", ")", "self", ".", "btn_bold", ".", "blockSignals", "(", "False", ")", "# refresh btn_italic", "self", ".", "btn_italic", ".", "blockSignals", "(", "True", ")", "self", ".", "btn_italic", ".", "setChecked", "(", "font", ".", "italic", "(", ")", ")", "self", ".", "btn_italic", ".", "blockSignals", "(", "False", ")", "# refresh font size", "self", ".", "spin_box", ".", "blockSignals", "(", "True", ")", "self", ".", "spin_box", ".", "setValue", "(", "font", ".", "pointSize", "(", ")", ")", "self", ".", "spin_box", ".", "blockSignals", "(", "False", ")" ]

[ "Refresh", "the", "widgets", "from", "the", "current", "font" ]

[ "def", "histogram_cluster_table", "(", "analyzed_data_file", ",", "output_file", ",", "chunk_size", "=", "10000000", ")", ":", "with", "tb", ".", "open_file", "(", "analyzed_data_file", ",", "mode", "=", "\"r\"", ")", "as", "in_file_h5", ":", "with", "tb", ".", "open_file", "(", "output_file", ",", "mode", "=", "\"w\"", ")", "as", "out_file_h5", ":", "histogram", "=", "PyDataHistograming", "(", ")", "histogram", ".", "create_occupancy_hist", "(", "True", ")", "scan_parameters", "=", "None", "event_number_indices", "=", "None", "scan_parameter_indices", "=", "None", "try", ":", "meta_data", "=", "in_file_h5", ".", "root", ".", "meta_data", "[", ":", "]", "scan_parameters", "=", "analysis_utils", ".", "get_unique_scan_parameter_combinations", "(", "meta_data", ")", "if", "scan_parameters", "is", "not", "None", ":", "scan_parameter_indices", "=", "np", ".", "array", "(", "range", "(", "0", ",", "len", "(", "scan_parameters", ")", ")", ",", "dtype", "=", "'u4'", ")", "event_number_indices", "=", "np", ".", "ascontiguousarray", "(", "scan_parameters", "[", "'event_number'", "]", ")", ".", "astype", "(", "np", ".", "uint64", ")", "histogram", ".", "add_meta_event_index", "(", "event_number_indices", ",", "array_length", "=", "len", "(", "scan_parameters", "[", "'event_number'", "]", ")", ")", "histogram", ".", "add_scan_parameter", "(", "scan_parameter_indices", ")", "logging", ".", "info", "(", "\"Add %d different scan parameter(s) for analysis\"", ",", "len", "(", "scan_parameters", ")", ")", "else", ":", "logging", ".", "info", "(", "\"No scan parameter data provided\"", ")", "histogram", ".", "set_no_scan_parameter", "(", ")", "except", "tb", ".", "exceptions", ".", "NoSuchNodeError", ":", "logging", ".", "info", "(", "\"No meta data provided, use no scan parameter\"", ")", "histogram", ".", "set_no_scan_parameter", "(", ")", "logging", ".", "info", "(", "'Histogram cluster seeds...'", ")", "progress_bar", "=", "progressbar", ".", "ProgressBar", "(", "widgets", "=", "[", "''", ",", "progressbar", ".", "Percentage", "(", ")", ",", "' '", ",", "progressbar", ".", "Bar", "(", "marker", "=", "'*'", ",", "left", "=", "'|'", ",", "right", "=", "'|'", ")", ",", "' '", ",", "progressbar", ".", "AdaptiveETA", "(", ")", "]", ",", "maxval", "=", "in_file_h5", ".", "root", ".", "Cluster", ".", "shape", "[", "0", "]", ",", "term_width", "=", "80", ")", "progress_bar", ".", "start", "(", ")", "total_cluster", "=", "0", "# to check analysis", "for", "cluster", ",", "index", "in", "analysis_utils", ".", "data_aligned_at_events", "(", "in_file_h5", ".", "root", ".", "Cluster", ",", "chunk_size", "=", "chunk_size", ")", ":", "total_cluster", "+=", "len", "(", "cluster", ")", "histogram", ".", "add_cluster_seed_hits", "(", "cluster", ",", "len", "(", "cluster", ")", ")", "progress_bar", ".", "update", "(", "index", ")", "progress_bar", ".", "finish", "(", ")", "filter_table", "=", "tb", ".", "Filters", "(", "complib", "=", "'blosc'", ",", "complevel", "=", "5", ",", "fletcher32", "=", "False", ")", "# compression of the written data", "occupancy_array", "=", "histogram", ".", "get_occupancy", "(", ")", ".", "T", "occupancy_array_table", "=", "out_file_h5", ".", "create_carray", "(", "out_file_h5", ".", "root", ",", "name", "=", "'HistOcc'", ",", "title", "=", "'Occupancy Histogram'", ",", "atom", "=", "tb", ".", "Atom", ".", "from_dtype", "(", "occupancy_array", ".", "dtype", ")", ",", "shape", "=", "occupancy_array", ".", "shape", ",", "filters", "=", "filter_table", ")", "occupancy_array_table", "[", ":", "]", "=", "occupancy_array", "if", "total_cluster", "!=", "np", ".", "sum", "(", "occupancy_array", ")", ":", "logging", ".", "warning", "(", "'Analysis shows inconsistent number of cluster used. Check needed!'", ")", "in_file_h5", ".", "root", ".", "meta_data", ".", "copy", "(", "out_file_h5", ".", "root", ")" ]

[ "Reads", "in", "the", "cluster", "info", "table", "in", "chunks", "and", "histograms", "the", "seed", "pixels", "into", "one", "occupancy", "array", ".", "The", "3rd", "dimension", "of", "the", "occupancy", "array", "is", "the", "number", "of", "different", "scan", "parameters", "used" ]

[ "def", "shift_right", "(", "x", ",", "pad_value", "=", "None", ")", ":", "if", "pad_value", "is", "None", ":", "shifted_targets", "=", "tf", ".", "pad", "(", "x", ",", "[", "[", "0", ",", "0", "]", ",", "[", "1", ",", "0", "]", ",", "[", "0", ",", "0", "]", ",", "[", "0", ",", "0", "]", "]", ")", "[", ":", ",", ":", "-", "1", ",", ":", ",", ":", "]", "else", ":", "shifted_targets", "=", "tf", ".", "concat", "(", "[", "pad_value", ",", "x", "]", ",", "axis", "=", "1", ")", "[", ":", ",", ":", "-", "1", ",", ":", ",", ":", "]", "return", "shifted_targets" ]

[ "Shift", "the", "second", "dimension", "of", "x", "right", "by", "one", "." ]

[ "def", "fix_page_relative_url", "(", "rel_url", ")", ":", "rel_url", "=", "rel_url", ".", "lstrip", "(", "'/'", ")", "# trim all heading '/'", "endswith_slash", "=", "rel_url", ".", "endswith", "(", "'/'", ")", "rel_url", "=", "rel_url", ".", "rstrip", "(", "'/'", ")", "+", "(", "'/'", "if", "endswith_slash", "else", "''", ")", "# preserve only one trailing '/'", "if", "not", "rel_url", "or", "rel_url", "==", "'/'", ":", "return", "None", ",", "False", "file_path", "=", "os", ".", "path", ".", "join", "(", "current_app", ".", "instance_path", ",", "'pages'", ",", "rel_url", ".", "replace", "(", "'/'", ",", "os", ".", "path", ".", "sep", ")", ")", "if", "rel_url", ".", "endswith", "(", "'/'", ")", ":", "index_html_file_path", "=", "os", ".", "path", ".", "join", "(", "file_path", ",", "'index.html'", ")", "if", "os", ".", "path", ".", "isfile", "(", "index_html_file_path", ")", ":", "# index.html exists", "return", "index_html_file_path", ",", "True", "return", "rel_url", ",", "False", "elif", "os", ".", "path", ".", "isfile", "(", "file_path", ")", ":", "ext", "=", "os", ".", "path", ".", "splitext", "(", "file_path", ")", "[", "1", "]", "[", "1", ":", "]", "if", "get_standard_format_name", "(", "ext", ")", "is", "not", "None", ":", "# is source of custom page", "if", "current_app", ".", "config", "[", "'PAGE_SOURCE_ACCESSIBLE'", "]", ":", "return", "file_path", ",", "True", "else", ":", "# is other direct files", "return", "file_path", ",", "True", "elif", "os", ".", "path", ".", "isdir", "(", "file_path", ")", ":", "return", "rel_url", "+", "'/'", ",", "False", "sp", "=", "rel_url", ".", "rsplit", "(", "'/'", ",", "1", ")", "m", "=", "re", ".", "match", "(", "r'(.+)\\.html?'", ",", "sp", "[", "-", "1", "]", ")", "if", "m", ":", "sp", "[", "-", "1", "]", "=", "m", ".", "group", "(", "1", ")", "+", "'.html'", "else", ":", "sp", "[", "-", "1", "]", "+=", "'.html'", "return", "'/'", ".", "join", "(", "sp", ")", ",", "False" ]

[ "Fix", "page", "relative", "url", "to", "a", "standard", "uniform", "format", "." ]

[ "def", "read_l2tp", "(", "self", ",", "length", ")", ":", "if", "length", "is", "None", ":", "length", "=", "len", "(", "self", ")", "_flag", "=", "self", ".", "_read_binary", "(", "1", ")", "_vers", "=", "self", ".", "_read_fileng", "(", "1", ")", ".", "hex", "(", ")", "[", "1", "]", "_hlen", "=", "self", ".", "_read_unpack", "(", "2", ")", "if", "int", "(", "_flag", "[", "1", "]", ")", "else", "None", "_tnnl", "=", "self", ".", "_read_unpack", "(", "2", ")", "_sssn", "=", "self", ".", "_read_unpack", "(", "2", ")", "_nseq", "=", "self", ".", "_read_unpack", "(", "2", ")", "if", "int", "(", "_flag", "[", "4", "]", ")", "else", "None", "_nrec", "=", "self", ".", "_read_unpack", "(", "2", ")", "if", "int", "(", "_flag", "[", "4", "]", ")", "else", "None", "_size", "=", "self", ".", "_read_unpack", "(", "2", ")", "if", "int", "(", "_flag", "[", "6", "]", ")", "else", "0", "l2tp", "=", "dict", "(", "flags", "=", "dict", "(", "type", "=", "'Control'", "if", "int", "(", "_flag", "[", "0", "]", ")", "else", "'Data'", ",", "len", "=", "True", "if", "int", "(", "_flag", "[", "1", "]", ")", "else", "False", ",", "seq", "=", "True", "if", "int", "(", "_flag", "[", "4", "]", ")", "else", "False", ",", "offset", "=", "True", "if", "int", "(", "_flag", "[", "6", "]", ")", "else", "False", ",", "prio", "=", "True", "if", "int", "(", "_flag", "[", "7", "]", ")", "else", "False", ",", ")", ",", "ver", "=", "int", "(", "_vers", ",", "base", "=", "16", ")", ",", "length", "=", "_hlen", ",", "tunnelid", "=", "_tnnl", ",", "sessionid", "=", "_sssn", ",", "ns", "=", "_nseq", ",", "nr", "=", "_nrec", ",", "offset", "=", "8", "*", "_size", "or", "None", ",", ")", "hdr_len", "=", "_hlen", "or", "(", "6", "+", "2", "*", "(", "int", "(", "_flag", "[", "1", "]", ")", "+", "2", "*", "int", "(", "_flag", "[", "4", "]", ")", "+", "int", "(", "_flag", "[", "6", "]", ")", ")", ")", "l2tp", "[", "'hdr_len'", "]", "=", "hdr_len", "+", "_size", "*", "8", "# if _size:", "# l2tp['padding'] = self._read_fileng(_size * 8)", "length", "-=", "l2tp", "[", "'hdr_len'", "]", "l2tp", "[", "'packet'", "]", "=", "self", ".", "_read_packet", "(", "header", "=", "l2tp", "[", "'hdr_len'", "]", ",", "payload", "=", "length", ")", "return", "self", ".", "_decode_next_layer", "(", "l2tp", ",", "length", ")" ]

[ "Read", "Layer", "Two", "Tunnelling", "Protocol", "." ]

[ "def", "default_config_file", "(", "self", ")", ":", "import", "os", ".", "path", "as", "p", "import", "pyemma", "return", "p", ".", "join", "(", "pyemma", ".", "__path__", "[", "0", "]", ",", "Config", ".", "DEFAULT_CONFIG_FILE_NAME", ")" ]

[ "default", "config", "file", "living", "in", "PyEMMA", "package" ]

[ "def", "release_readlock", "(", "lockdir_name", ")", ":", "# Make sure the lock still exists before deleting it", "if", "os", ".", "path", ".", "exists", "(", "lockdir_name", ")", "and", "os", ".", "path", ".", "isdir", "(", "lockdir_name", ")", ":", "os", ".", "rmdir", "(", "lockdir_name", ")" ]

[ "Release", "a", "previously", "obtained", "readlock", "." ]

[ "def", "client", "(", "self", ")", ":", "if", "self", ".", "_client", "is", "not", "None", ":", "return", "self", ".", "_client", "self", ".", "_client", "=", "self", ".", "get_client", "(", ")", "return", "self", ".", "_client" ]

[ "Helper", "property", "to", "lazy", "initialize", "and", "cache", "client", ".", "Runs", ":", "meth", ":", "~django_docker_helpers", ".", "config", ".", "backends", ".", "base", ".", "BaseParser", ".", "get_client", "." ]

[ "def", "_ask", "(", "question", ",", "default", "=", "None", ",", "data_type", "=", "'str'", ",", "show_hint", "=", "False", ")", ":", "data", "=", "default", "if", "data_type", "==", "'bool'", ":", "data", "=", "None", "default_string", "=", "\"Y\"", "if", "default", "else", "\"N\"", "while", "data", "not", "in", "(", "'Y'", ",", "'J'", ",", "'N'", ",", "'1'", ",", "'0'", ")", ":", "data", "=", "input", "(", "\"%s? [%s]: \"", "%", "(", "question", ",", "default_string", ")", ")", ".", "upper", "(", ")", "if", "data", "==", "''", ":", "return", "default", "return", "data", "in", "(", "'Y'", ",", "'J'", ",", "'1'", ")", "elif", "data_type", "in", "(", "'str'", ",", "'unicode'", ")", ":", "if", "show_hint", ":", "msg", "=", "\"%s? [%s] (%s): \"", "%", "(", "question", ",", "default", ",", "data_type", ")", "else", ":", "msg", "=", "question", "data", "=", "input", "(", "msg", ")", "if", "len", "(", "data", ")", "==", "0", ":", "data", "=", "default", "elif", "data_type", "==", "'int'", ":", "if", "show_hint", ":", "msg", "=", "\"%s? [%s] (%s): \"", "%", "(", "question", ",", "default", ",", "data_type", ")", "else", ":", "msg", "=", "question", "data", "=", "input", "(", "msg", ")", "if", "len", "(", "data", ")", "==", "0", ":", "data", "=", "int", "(", "default", ")", "else", ":", "data", "=", "int", "(", "data", ")", "return", "data" ]

[ "Interactively", "ask", "the", "user", "for", "data" ]

[ "def", "p_concat", "(", "self", ",", "p", ")", ":", "p", "[", "0", "]", "=", "Concat", "(", "p", "[", "2", "]", ",", "lineno", "=", "p", ".", "lineno", "(", "1", ")", ")", "p", ".", "set_lineno", "(", "0", ",", "p", ".", "lineno", "(", "1", ")", ")" ]

[ "concat", ":", "LBRACE", "concatlist", "RBRACE" ]

[ "def", "drawBackground", "(", "self", ",", "painter", ",", "rect", ")", ":", "if", "(", "self", ".", "_rebuildRequired", ")", ":", "self", ".", "rebuild", "(", ")", "super", "(", "XCalendarScene", ",", "self", ")", ".", "drawBackground", "(", "painter", ",", "rect", ")", "palette", "=", "self", ".", "palette", "(", ")", "# draw custom options\r", "if", "(", "'curr_date'", "in", "self", ".", "_buildData", ")", ":", "clr", "=", "palette", ".", "color", "(", "QPalette", ".", "Highlight", ")", "clr", ".", "setAlpha", "(", "40", ")", "painter", ".", "setBrush", "(", "clr", ")", "painter", ".", "setPen", "(", "Qt", ".", "NoPen", ")", "painter", ".", "drawRect", "(", "self", ".", "_buildData", "[", "'curr_date'", "]", ")", "painter", ".", "setBrush", "(", "Qt", ".", "NoBrush", ")", "if", "(", "'today'", "in", "self", ".", "_buildData", ")", ":", "painter", ".", "setPen", "(", "Qt", ".", "NoPen", ")", "clr", "=", "palette", ".", "color", "(", "QPalette", ".", "AlternateBase", ")", "clr", ".", "setAlpha", "(", "120", ")", "painter", ".", "setBrush", "(", "clr", ")", "painter", ".", "drawRect", "(", "self", ".", "_buildData", "[", "'today'", "]", ")", "painter", ".", "setBrush", "(", "Qt", ".", "NoBrush", ")", "# draw the grid\r", "painter", ".", "setPen", "(", "palette", ".", "color", "(", "QPalette", ".", "Mid", ")", ")", "painter", ".", "drawLines", "(", "self", ".", "_buildData", ".", "get", "(", "'grid'", ",", "[", "]", ")", ")", "# draw text fields\r", "painter", ".", "setPen", "(", "palette", ".", "color", "(", "QPalette", ".", "Text", ")", ")", "for", "data", "in", "self", ".", "_buildData", ".", "get", "(", "'regular_text'", ",", "[", "]", ")", ":", "painter", ".", "drawText", "(", "*", "data", ")", "# draw mid text fields\r", "painter", ".", "setPen", "(", "palette", ".", "color", "(", "QPalette", ".", "Mid", ")", ")", "for", "data", "in", "self", ".", "_buildData", ".", "get", "(", "'mid_text'", ",", "[", "]", ")", ":", "painter", ".", "drawText", "(", "*", "data", ")" ]

[ "Draws", "the", "background", "of", "the", "scene", "using", "painter", ".", ":", "param", "painter", "|", "<QPainter", ">", "rect", "|", "<QRectF", ">" ]

[ "def", "com_google_fonts_check_metadata_valid_full_name_values", "(", "style", ",", "font_metadata", ",", "font_familynames", ",", "typographic_familynames", ")", ":", "from", "fontbakery", ".", "constants", "import", "RIBBI_STYLE_NAMES", "if", "style", "in", "RIBBI_STYLE_NAMES", ":", "familynames", "=", "font_familynames", "if", "familynames", "==", "[", "]", ":", "yield", "SKIP", ",", "\"No FONT_FAMILYNAME\"", "else", ":", "familynames", "=", "typographic_familynames", "if", "familynames", "==", "[", "]", ":", "yield", "SKIP", ",", "\"No TYPOGRAPHIC_FAMILYNAME\"", "for", "font_familyname", "in", "familynames", ":", "if", "font_familyname", "in", "font_metadata", ".", "full_name", ":", "yield", "PASS", ",", "(", "\"METADATA.pb font.full_name field contains\"", "\" font name in right format.\"", "\" ('{}' in '{}')\"", ")", ".", "format", "(", "font_familyname", ",", "font_metadata", ".", "full_name", ")", "else", ":", "yield", "FAIL", ",", "(", "\"METADATA.pb font.full_name field (\\\"{}\\\")\"", "\" does not match correct font name format (\\\"{}\\\").\"", "\"\"", ")", ".", "format", "(", "font_metadata", ".", "full_name", ",", "font_familyname", ")" ]

[ "METADATA", ".", "pb", "font", ".", "full_name", "field", "contains", "font", "name", "in", "right", "format?" ]

[ "def", "plot_freq", "(", "self", ",", "x", ",", "y", ",", "title", "=", "''", ",", "ylabel", "=", "None", ",", "scale", "=", "'semilogy'", ")", ":", "freq", "=", "self", ".", "frequency", "scaling", "=", "freq", "[", "'scaling'", "]", ".", "get_value", "(", ")", "if", "ylabel", "is", "None", ":", "if", "freq", "[", "'complex'", "]", ".", "get_value", "(", ")", ":", "ylabel", "=", "'Amplitude (uV)'", "elif", "'power'", "==", "scaling", ":", "ylabel", "=", "'Power spectral density (uV ** 2 / Hz)'", "elif", "'energy'", "==", "scaling", ":", "ylabel", "=", "'Energy spectral density (uV ** 2)'", "self", ".", "parent", ".", "plot_dialog", "=", "PlotDialog", "(", "self", ".", "parent", ")", "self", ".", "parent", ".", "plot_dialog", ".", "canvas", ".", "plot", "(", "x", ",", "y", ",", "title", ",", "ylabel", ",", "scale", "=", "scale", ")", "self", ".", "parent", ".", "show_plot_dialog", "(", ")" ]

[ "Plot", "mean", "frequency", "spectrum", "and", "display", "in", "dialog", "." ]

[ "def", "dr", "(", "self", ",", "r1", ",", "r2", ",", "cutoff", "=", "None", ")", ":", "delta_r_cartesian", "=", "(", "r1", "-", "r2", ")", ".", "dot", "(", "self", ".", "matrix", ")", "delta_r_squared", "=", "sum", "(", "delta_r_cartesian", "**", "2", ")", "if", "cutoff", "!=", "None", ":", "cutoff_squared", "=", "cutoff", "**", "2", "if", "delta_r_squared", ">", "cutoff_squared", ":", "return", "None", "return", "(", "math", ".", "sqrt", "(", "delta_r_squared", ")", ")" ]

[ "Calculate", "the", "distance", "between", "two", "fractional", "coordinates", "in", "the", "cell", ".", "Args", ":", "r1", "(", "np", ".", "array", ")", ":", "fractional", "coordinates", "for", "position", "1", ".", "r2", "(", "np", ".", "array", ")", ":", "fractional", "coordinates", "for", "position", "2", ".", "cutoff", "(", "optional", ":", "Bool", ")", ":", "If", "set", "returns", "None", "for", "distances", "greater", "than", "the", "cutoff", ".", "Default", "None", "(", "unset", ")", "." ]

[ "def", "mechanism", "(", "self", ",", "mechanism", ")", ":", "allowed_values", "=", "[", "\"connector\"", ",", "\"direct\"", "]", "if", "mechanism", "not", "in", "allowed_values", ":", "raise", "ValueError", "(", "\"Invalid value for `mechanism` ({0}), must be one of {1}\"", ".", "format", "(", "mechanism", ",", "allowed_values", ")", ")", "self", ".", "_mechanism", "=", "mechanism" ]

[ "Sets", "the", "mechanism", "of", "this", "DeviceData", ".", "The", "ID", "of", "the", "channel", "used", "to", "communicate", "with", "the", "device", "." ]

[ "def", "read", "(", "self", ",", "device", "=", "None", ",", "offset", "=", "0", ",", "bs", "=", "None", ",", "count", "=", "1", ")", ":", "volume", "=", "self", ".", "get_volume", "(", "device", ")", "block_size", "=", "bs", "or", "BLOCK_SIZE", "offset", "=", "int", "(", "offset", ")", "*", "block_size", "count", "=", "int", "(", "count", ")", "print", "(", "\"Offset: \"", ",", "offset", ")", "total", "=", "0", "with", "directio", ".", "open", "(", "volume", "[", "'path'", "]", ",", "buffered", "=", "block_size", ")", "as", "file", ":", "file", ".", "seek", "(", "offset", ")", "for", "i", "in", "range", "(", "0", ",", "count", ")", ":", "total", "+=", "os", ".", "write", "(", "sys", ".", "stdout", ".", "fileno", "(", ")", ",", "file", ".", "read", "(", "block_size", ")", ")", "os", ".", "write", "(", "sys", ".", "stdout", ".", "fileno", "(", ")", ",", "\"\\nRead: %d Bytes\\n\"", "%", "total", ")" ]

[ "Using", "DIRECT_O", "read", "from", "the", "block", "device", "specified", "to", "stdout", "(", "Without", "any", "optional", "arguments", "will", "read", "the", "first", "4k", "from", "the", "device", ")" ]

[ "def", "_bivariate_handler", "(", "df", ",", "x", ",", "y", "=", "None", ",", "w", "=", "None", ",", "inplace", "=", "True", ",", "pvalue", "=", "'sim'", ",", "outvals", "=", "None", ",", "*", "*", "kwargs", ")", ":", "real_swapname", "=", "kwargs", ".", "pop", "(", "'swapname'", ",", "''", ")", "if", "isinstance", "(", "y", ",", "str", ")", ":", "y", "=", "[", "y", "]", "if", "isinstance", "(", "x", ",", "str", ")", ":", "x", "=", "[", "x", "]", "if", "not", "inplace", ":", "new_df", "=", "df", ".", "copy", "(", ")", "_bivariate_handler", "(", "new_df", ",", "x", ",", "y", "=", "y", ",", "w", "=", "w", ",", "inplace", "=", "True", ",", "swapname", "=", "real_swapname", ",", "pvalue", "=", "pvalue", ",", "outvals", "=", "outvals", ",", "*", "*", "kwargs", ")", "return", "new_df", "if", "y", "is", "None", ":", "y", "=", "x", "for", "xi", ",", "yi", "in", "_it", ".", "product", "(", "x", ",", "y", ")", ":", "if", "xi", "==", "yi", ":", "continue", "_univariate_handler", "(", "df", ",", "cols", "=", "xi", ",", "w", "=", "w", ",", "y", "=", "df", "[", "yi", "]", ",", "inplace", "=", "True", ",", "pvalue", "=", "pvalue", ",", "outvals", "=", "outvals", ",", "swapname", "=", "''", ",", "*", "*", "kwargs", ")", "if", "real_swapname", "is", "not", "''", ":", "df", ".", "columns", "=", "[", "_swap_ending", "(", "col", ",", "real_swapname", ")", "if", "col", ".", "endswith", "(", "'_statistic'", ")", "else", "col", "for", "col", "in", "df", ".", "columns", "]" ]

[ "Compute", "a", "descriptive", "bivariate", "statistic", "over", "two", "sets", "of", "columns", "x", "and", "y", "contained", "in", "df", "." ]

[ "def", "_generate_base_anchors", "(", "base_size", ",", "scales", ",", "ratios", ")", ":", "base_anchor", "=", "np", ".", "array", "(", "[", "1", ",", "1", ",", "base_size", ",", "base_size", "]", ")", "-", "1", "ratio_anchors", "=", "AnchorGenerator", ".", "_ratio_enum", "(", "base_anchor", ",", "ratios", ")", "anchors", "=", "np", ".", "vstack", "(", "[", "AnchorGenerator", ".", "_scale_enum", "(", "ratio_anchors", "[", "i", ",", ":", "]", ",", "scales", ")", "for", "i", "in", "range", "(", "ratio_anchors", ".", "shape", "[", "0", "]", ")", "]", ")", "return", "anchors" ]

[ "Generate", "anchor", "(", "reference", ")", "windows", "by", "enumerating", "aspect", "ratios", "X", "scales", "wrt", "a", "reference", "(", "0", "0", "15", "15", ")", "window", "." ]

[ "def", "_find_record", "(", "self", ",", "domain", ",", "_type", "=", "None", ")", ":", "def", "_is_matching", "(", "record", ")", ":", "\"\"\"filter function for records\"\"\"", "if", "domain", "and", "record", ".", "get", "(", "'domain'", ",", "None", ")", "!=", "domain", ":", "return", "False", "if", "_type", "and", "record", ".", "get", "(", "'type'", ",", "None", ")", "!=", "_type", ":", "return", "False", "return", "True", "payload", "=", "self", ".", "_get", "(", "'/search?q={0}&type=record'", ".", "format", "(", "domain", ")", ")", "for", "record", "in", "payload", ":", "if", "_is_matching", "(", "record", ")", ":", "match", "=", "record", "break", "else", ":", "# no such domain on ns1", "return", "None", "record", "=", "self", ".", "_get", "(", "'/zones/{0}/{1}/{2}'", ".", "format", "(", "match", "[", "'zone'", "]", ",", "match", "[", "'domain'", "]", ",", "match", "[", "'type'", "]", ")", ")", "if", "record", ".", "get", "(", "'message'", ",", "None", ")", ":", "return", "None", "# {\"message\":\"record not found\"}", "short_answers", "=", "[", "x", "[", "'answer'", "]", "[", "0", "]", "for", "x", "in", "record", "[", "'answers'", "]", "]", "# ensure a compatibility level with self._list_records", "record", "[", "'short_answers'", "]", "=", "short_answers", "return", "record" ]

[ "search", "for", "a", "record", "on", "NS1", "across", "zones", ".", "returns", "None", "if", "not", "found", "." ]

[ "def", "find_shift_dft", "(", "im0", ",", "im1", ",", "isccs", "=", "False", ",", "subpix", "=", "True", ")", ":", "# sanitize input", "im0", "=", "np", ".", "asarray", "(", "im0", ",", "dtype", "=", "np", ".", "float32", ")", "im1", "=", "np", ".", "asarray", "(", "im1", ",", "dtype", "=", "np", ".", "float32", ")", "# check input", "if", "not", "isccs", ":", "im0", ",", "im1", "=", "dft_optsize_same", "(", "im0", ",", "im1", ")", "else", ":", "# Work only if the shapes are the same", "assert", "(", "im0", ".", "shape", "==", "im1", ".", "shape", ")", "# f0*conj(f1)", "mulSpec", "=", "cv2", ".", "mulSpectrums", "(", "im0", ",", "im1", ",", "flags", "=", "0", ",", "conjB", "=", "True", ")", "# norm(f0)*norm(f1)", "normccs", "=", "cv2", ".", "sqrt", "(", "cv2", ".", "mulSpectrums", "(", "im0", ",", "im0", ",", "flags", "=", "0", ",", "conjB", "=", "True", ")", "*", "cv2", ".", "mulSpectrums", "(", "im1", ",", "im1", ",", "flags", "=", "0", ",", "conjB", "=", "True", ")", ")", "# compute the inverse DFT", "xc", "=", "cv2", ".", "dft", "(", "ccs_normalize", "(", "mulSpec", ",", "normccs", ")", ",", "flags", "=", "cv2", ".", "DFT_REAL_OUTPUT", "|", "cv2", ".", "DFT_INVERSE", ")", "# Blur xc to remove some noise and improve the subpixel detection", "# workaround as GaussianBlur doesn't work with BORDER_WRAP", "blurRadii", "=", "2", "xc", "=", "cv2", ".", "copyMakeBorder", "(", "xc", ",", "blurRadii", ",", "blurRadii", ",", "blurRadii", ",", "blurRadii", ",", "borderType", "=", "cv2", ".", "BORDER_WRAP", ")", "xc", "=", "cv2", ".", "GaussianBlur", "(", "xc", ",", "(", "2", "*", "blurRadii", "+", "1", ",", "2", "*", "blurRadii", "+", "1", ")", ",", "1.5", ")", "xc", "=", "xc", "[", "blurRadii", ":", "-", "blurRadii", ",", "blurRadii", ":", "-", "blurRadii", "]", "# save shape", "shape", "=", "np", ".", "asarray", "(", "xc", ".", "shape", ")", "# find max", "idx", "=", "np", ".", "asarray", "(", "np", ".", "unravel_index", "(", "np", ".", "argmax", "(", "xc", ")", ",", "shape", ")", ")", "\"\"\"\n from matplotlib import pyplot as plt\n from numpy.fft import fftshift\n plt.figure()\n plt.imshow(np.log(np.abs(fftshift(im0))))\n plt.figure()\n plt.imshow(np.log(np.abs(fftshift(im1))))\n plt.figure()\n plt.imshow(fftshift(ccs_normalize(mulSpec,normccs)))\n plt.figure()\n extent= (-np.shape(xc)[1]/2, np.shape(xc)[1]/2, -np.shape(xc)[0]/2, np.shape(xc)[0]/2 )\n plt.imshow(np.log(np.abs(fftshift(xc))),extent = extent)\n\n #\"\"\"", "# plt.imshow(fftshift(xc))", "# print(idx)", "# plt.figure()", "# if toremove:", "# plt.figure(1)", "# l=len(xc[:,0])", "# plt.plot(np.arange(l)/l,xc[:,0])", "# print(l,xc[-1,0])", "# plt.figure(2)", "#\"\"\"", "if", "subpix", ":", "# update idx", "idx", "=", "np", ".", "asarray", "(", "[", "get_peak_pos", "(", "xc", "[", ":", ",", "idx", "[", "1", "]", "]", ",", "wrap", "=", "True", ")", ",", "get_peak_pos", "(", "xc", "[", "idx", "[", "0", "]", ",", ":", "]", ",", "wrap", "=", "True", ")", "]", ")", "else", ":", "# restrics to reasonable values", "idx", "[", "idx", ">", "shape", "//", "2", "]", "-=", "shape", "[", "idx", ">", "shape", "//", "2", "]", "return", "idx" ]

[ "Find", "the", "shift", "between", "two", "images", "using", "the", "DFT", "method" ]

[ "def", "do_it", "(", "self", ",", "dbg", ")", ":", "try", ":", "var_objects", "=", "[", "]", "for", "variable", "in", "self", ".", "vars", ":", "variable", "=", "variable", ".", "strip", "(", ")", "if", "len", "(", "variable", ")", ">", "0", ":", "if", "'\\t'", "in", "variable", ":", "# there are attributes beyond scope", "scope", ",", "attrs", "=", "variable", ".", "split", "(", "'\\t'", ",", "1", ")", "name", "=", "attrs", "[", "0", "]", "else", ":", "scope", ",", "attrs", "=", "(", "variable", ",", "None", ")", "name", "=", "scope", "var_obj", "=", "pydevd_vars", ".", "getVariable", "(", "dbg", ",", "self", ".", "thread_id", ",", "self", ".", "frame_id", ",", "scope", ",", "attrs", ")", "var_objects", ".", "append", "(", "(", "var_obj", ",", "name", ")", ")", "t", "=", "GetValueAsyncThreadDebug", "(", "dbg", ",", "self", ".", "sequence", ",", "var_objects", ")", "t", ".", "start", "(", ")", "except", ":", "exc", "=", "get_exception_traceback_str", "(", ")", "sys", ".", "stderr", ".", "write", "(", "'%s\\n'", "%", "(", "exc", ",", ")", ")", "cmd", "=", "dbg", ".", "cmd_factory", ".", "make_error_message", "(", "self", ".", "sequence", ",", "\"Error evaluating variable %s \"", "%", "exc", ")", "dbg", ".", "writer", ".", "add_command", "(", "cmd", ")" ]

[ "Starts", "a", "thread", "that", "will", "load", "values", "asynchronously" ]

[ "def", "setfillmode", "(", "self", ",", "fill_mode", ")", ":", "if", "not", "fill_mode", "in", "[", "SDC", ".", "FILL", ",", "SDC", ".", "NOFILL", "]", ":", "raise", "HDF4Error", "(", "\"bad fill mode\"", ")", "old_mode", "=", "_C", ".", "SDsetfillmode", "(", "self", ".", "_id", ",", "fill_mode", ")", "_checkErr", "(", "'setfillmode'", ",", "old_mode", ",", "'cannot execute'", ")", "return", "old_mode" ]

[ "Set", "the", "fill", "mode", "for", "all", "the", "datasets", "in", "the", "file", "." ]

[ "def", "getDownload", "(", "self", ",", "params", ")", ":", "df", "=", "self", ".", "getData", "(", "params", ")", "buffer", "=", "io", ".", "StringIO", "(", ")", "df", ".", "to_csv", "(", "buffer", ",", "index", "=", "False", ",", "encoding", "=", "'utf-8'", ")", "filepath", "=", "buffer", "return", "filepath" ]

[ "Override", "this", "function" ]

[ "def", "get_taker_id", "(", "self", ")", ":", "if", "self", ".", "_my_map", "[", "'takerId'", "]", ":", "return", "Id", "(", "self", ".", "_my_map", "[", "'takerId'", "]", ")", "else", ":", "return", "Id", "(", "self", ".", "_my_map", "[", "'takingAgentId'", "]", ")" ]

[ "Gets", "the", "Id", "of", "the", "resource", "who", "took", "or", "is", "taking", "this", "assessment", "." ]

[ "def", "fit", "(", "self", ",", "method", "=", "'fmin_powell'", ",", "iterlim", "=", "1000", ",", "tol", "=", ".0001", ",", "verbose", "=", "0", ",", "no_callback", "=", "False", ",", "*", "*", "kwargs", ")", ":", "self", ".", "tol", "=", "tol", "self", ".", "method", "=", "method", "self", ".", "verbose", "=", "verbose", "p", "=", "zeros", "(", "self", ".", "len", ",", "dtype", "=", "float", ")", "for", "stochastic", "in", "self", ".", "stochastics", ":", "p", "[", "self", ".", "_slices", "[", "stochastic", "]", "]", "=", "ravel", "(", "stochastic", ".", "value", ")", "if", "not", "self", ".", "method", "==", "'newton'", ":", "if", "not", "scipy_imported", ":", "raise", "ImportError", "(", "'Scipy is required to use EM and NormApprox'", ")", "default_callback", "=", "(", "verbose", ">", "0", "and", "not", "no_callback", ")", "if", "default_callback", "and", "'callback'", "in", "kwargs", ":", "raise", "ValueError", "(", "\"For user-provided callback and verbose output\"", "\" set use_callback to True\"", ")", "if", "default_callback", ":", "def", "callback", "(", "p", ")", ":", "try", ":", "print_", "(", "'Current log-probability : %f'", "%", "self", ".", "logp", ")", "except", "ZeroProbability", ":", "print_", "(", "'Current log-probability : %f'", "%", "-", "Inf", ")", "elif", "'callback'", "in", "kwargs", ":", "callback", "=", "kwargs", ".", "pop", "(", "'callback'", ")", "else", ":", "def", "callback", "(", "p", ")", ":", "pass", "if", "self", ".", "method", "==", "'fmin_ncg'", ":", "p", "=", "fmin_ncg", "(", "f", "=", "self", ".", "func", ",", "x0", "=", "p", ",", "fprime", "=", "self", ".", "gradfunc", ",", "fhess", "=", "self", ".", "hessfunc", ",", "epsilon", "=", "self", ".", "eps", ",", "maxiter", "=", "iterlim", ",", "callback", "=", "callback", ",", "avextol", "=", "tol", ",", "disp", "=", "verbose", ",", "*", "*", "kwargs", ")", "elif", "self", ".", "method", "==", "'fmin'", ":", "p", "=", "fmin", "(", "func", "=", "self", ".", "func", ",", "x0", "=", "p", ",", "callback", "=", "callback", ",", "maxiter", "=", "iterlim", ",", "ftol", "=", "tol", ",", "disp", "=", "verbose", ",", "*", "*", "kwargs", ")", "elif", "self", ".", "method", "==", "'fmin_powell'", ":", "p", "=", "fmin_powell", "(", "func", "=", "self", ".", "func", ",", "x0", "=", "p", ",", "callback", "=", "callback", ",", "maxiter", "=", "iterlim", ",", "ftol", "=", "tol", ",", "disp", "=", "verbose", ",", "*", "*", "kwargs", ")", "elif", "self", ".", "method", "==", "'fmin_cg'", ":", "p", "=", "fmin_cg", "(", "f", "=", "self", ".", "func", ",", "x0", "=", "p", ",", "fprime", "=", "self", ".", "gradfunc", ",", "epsilon", "=", "self", ".", "eps", ",", "callback", "=", "callback", ",", "maxiter", "=", "iterlim", ",", "gtol", "=", "tol", ",", "disp", "=", "verbose", ",", "*", "*", "kwargs", ")", "elif", "self", ".", "method", "==", "'fmin_l_bfgs_b'", ":", "from", "scipy", "import", "__version__", "as", "sp_version", "from", "distutils", ".", "version", "import", "LooseVersion", "if", "LooseVersion", "(", "sp_version", ")", ">=", "LooseVersion", "(", "'0.12.0'", ")", ":", "p", "=", "fmin_l_bfgs_b", "(", "func", "=", "self", ".", "func", ",", "x0", "=", "p", ",", "fprime", "=", "self", ".", "gradfunc", ",", "epsilon", "=", "self", ".", "eps", ",", "callback", "=", "callback", ",", "pgtol", "=", "tol", ",", "iprint", "=", "verbose", "-", "1", ",", "*", "*", "kwargs", ")", "[", "0", "]", "else", ":", "if", "verbose", ">", "0", ":", "from", "warnings", "import", "warn", "warn", "(", "\"Callbacks are not available for fmin_l_bfgs_b in \"", "\"SciPy < 0.12.0. Optimization progress will not be\"", "\"displayed.\"", ",", "UserWarning", ")", "p", "=", "fmin_l_bfgs_b", "(", "func", "=", "self", ".", "func", ",", "x0", "=", "p", ",", "fprime", "=", "self", ".", "gradfunc", ",", "epsilon", "=", "self", ".", "eps", ",", "pgtol", "=", "tol", ",", "iprint", "=", "verbose", "-", "1", ",", "*", "*", "kwargs", ")", "[", "0", "]", "else", ":", "raise", "ValueError", "(", "'Method unknown.'", ")", "self", ".", "_set_stochastics", "(", "p", ")", "self", ".", "_mu", "=", "p", "try", ":", "self", ".", "logp_at_max", "=", "self", ".", "logp", "except", ":", "raise", "RuntimeError", "(", "'Posterior probability optimization converged to value with zero probability.'", ")", "lnL", "=", "sum", "(", "[", "x", ".", "logp", "for", "x", "in", "self", ".", "observed_stochastics", "]", ")", "# log-likelihood of observed stochastics", "self", ".", "lnL", "=", "lnL", "try", ":", "self", ".", "AIC", "=", "2.", "*", "(", "self", ".", "len", "-", "lnL", ")", "# 2k - 2 ln(L)", "self", ".", "AICc", "=", "self", ".", "AIC", "+", "(", "(", "2", "*", "self", ".", "len", "*", "(", "self", ".", "len", "+", "1", ")", ")", "/", "float", "(", "self", ".", "data_len", "-", "self", ".", "len", "-", "1", ")", ")", "except", "Exception", "as", "e", ":", "print", "(", "'Cannot calculate AIC:'", ",", "e", ")", "self", ".", "AICc", "=", "self", ".", "AIC", "=", "-", "Inf", "try", ":", "self", ".", "BIC", "=", "self", ".", "len", "*", "log", "(", "self", ".", "data_len", ")", "-", "2.", "*", "lnL", "# k ln(n) - 2 ln(L)", "except", "FloatingPointError", "as", "e", ":", "print", "(", "'Cannot calculate BIC:'", ",", "e", ")", "self", ".", "BIC", "=", "-", "Inf", "self", ".", "fitted", "=", "True" ]

[ "N", ".", "fit", "(", "method", "=", "fmin_powell", "iterlim", "=", "1000", "tol", "=", ".", "001", ")", ":" ]

[ "def", "reset", "(", "self", ")", ":", "self", ".", "L4", ".", "reset", "(", ")", "for", "module", "in", "self", ".", "L6aModules", ":", "module", ".", "reset", "(", ")" ]

[ "Clear", "all", "cell", "activity", "." ]

[ "def", "enqueued_time", "(", "self", ")", ":", "timestamp", "=", "self", ".", "_annotations", ".", "get", "(", "EventData", ".", "PROP_TIMESTAMP", ",", "None", ")", "if", "timestamp", ":", "return", "datetime", ".", "datetime", ".", "utcfromtimestamp", "(", "float", "(", "timestamp", ")", "/", "1000", ")", "return", "None" ]

[ "The", "enqueued", "timestamp", "of", "the", "event", "data", "object", "." ]

[ "def", "get_api_client", "(", "cls", ")", ":", "config", "=", "cloudsmith_api", ".", "Configuration", "(", ")", "client", "=", "cls", "(", ")", "client", ".", "config", "=", "config", "client", ".", "api_client", ".", "rest_client", "=", "RestClient", "(", ")", "user_agent", "=", "getattr", "(", "config", ",", "\"user_agent\"", ",", "None", ")", "if", "user_agent", ":", "client", ".", "api_client", ".", "user_agent", "=", "user_agent", "headers", "=", "getattr", "(", "config", ",", "\"headers\"", ",", "None", ")", "if", "headers", ":", "for", "k", ",", "v", "in", "six", ".", "iteritems", "(", "headers", ")", ":", "client", ".", "api_client", ".", "set_default_header", "(", "k", ",", "v", ")", "return", "client" ]

[ "Get", "an", "API", "client", "(", "with", "configuration", ")", "." ]

[ "def", "minimize", "(", "func", ",", "x0", ",", "data", "=", "None", ",", "method", "=", "None", ",", "lower_bounds", "=", "None", ",", "upper_bounds", "=", "None", ",", "constraints_func", "=", "None", ",", "nmr_observations", "=", "None", ",", "cl_runtime_info", "=", "None", ",", "options", "=", "None", ")", ":", "if", "not", "method", ":", "method", "=", "'Powell'", "cl_runtime_info", "=", "cl_runtime_info", "or", "CLRuntimeInfo", "(", ")", "if", "len", "(", "x0", ".", "shape", ")", "<", "2", ":", "x0", "=", "x0", "[", "...", ",", "None", "]", "lower_bounds", "=", "_bounds_to_array", "(", "lower_bounds", "or", "np", ".", "ones", "(", "x0", ".", "shape", "[", "1", "]", ")", "*", "-", "np", ".", "inf", ")", "upper_bounds", "=", "_bounds_to_array", "(", "upper_bounds", "or", "np", ".", "ones", "(", "x0", ".", "shape", "[", "1", "]", ")", "*", "np", ".", "inf", ")", "if", "method", "==", "'Powell'", ":", "return", "_minimize_powell", "(", "func", ",", "x0", ",", "cl_runtime_info", ",", "lower_bounds", ",", "upper_bounds", ",", "constraints_func", "=", "constraints_func", ",", "data", "=", "data", ",", "options", "=", "options", ")", "elif", "method", "==", "'Nelder-Mead'", ":", "return", "_minimize_nmsimplex", "(", "func", ",", "x0", ",", "cl_runtime_info", ",", "lower_bounds", ",", "upper_bounds", ",", "constraints_func", "=", "constraints_func", ",", "data", "=", "data", ",", "options", "=", "options", ")", "elif", "method", "==", "'Levenberg-Marquardt'", ":", "return", "_minimize_levenberg_marquardt", "(", "func", ",", "x0", ",", "nmr_observations", ",", "cl_runtime_info", ",", "lower_bounds", ",", "upper_bounds", ",", "constraints_func", "=", "constraints_func", ",", "data", "=", "data", ",", "options", "=", "options", ")", "elif", "method", "==", "'Subplex'", ":", "return", "_minimize_subplex", "(", "func", ",", "x0", ",", "cl_runtime_info", ",", "lower_bounds", ",", "upper_bounds", ",", "constraints_func", "=", "constraints_func", ",", "data", "=", "data", ",", "options", "=", "options", ")", "raise", "ValueError", "(", "'Could not find the specified method \"{}\".'", ".", "format", "(", "method", ")", ")" ]

[ "Minimization", "of", "one", "or", "more", "variables", "." ]

[ "def", "can_transfer", "(", "self", ",", "participant1", ":", "Address", ",", "participant2", ":", "Address", ",", "block_identifier", ":", "BlockSpecification", ",", "channel_identifier", ":", "ChannelID", ",", ")", "->", "bool", ":", "opened", "=", "self", ".", "channel_is_opened", "(", "participant1", "=", "participant1", ",", "participant2", "=", "participant2", ",", "block_identifier", "=", "block_identifier", ",", "channel_identifier", "=", "channel_identifier", ",", ")", "if", "opened", "is", "False", ":", "return", "False", "deposit", "=", "self", ".", "_detail_participant", "(", "channel_identifier", "=", "channel_identifier", ",", "participant", "=", "participant1", ",", "partner", "=", "participant2", ",", "block_identifier", "=", "block_identifier", ",", ")", ".", "deposit", "return", "deposit", ">", "0" ]

[ "Returns", "True", "if", "the", "channel", "is", "opened", "and", "the", "node", "has", "deposit", "in", "it", "." ]

[ "def", "tagger", "(", "self", ")", ":", "domain", "=", "0", "if", "domain", "not", "in", "self", ".", "domains", ":", "self", ".", "register_domain", "(", "domain", "=", "domain", ")", "return", "self", ".", "domains", "[", "domain", "]", ".", "tagger" ]

[ "A", "property", "to", "link", "into", "IntentEngine", "s", "intent_parsers", "." ]

[ "def", "msg_curse", "(", "self", ",", "args", "=", "None", ",", "max_width", "=", "None", ")", ":", "# Init the return message", "ret", "=", "[", "]", "# Only process if stats exist and display plugin enable...", "if", "not", "self", ".", "stats", "or", "self", ".", "is_disable", "(", ")", ":", "return", "ret", "# Max size for the interface name", "name_max_width", "=", "max_width", "-", "12", "# Header", "msg", "=", "'{:{width}}'", ".", "format", "(", "'SENSORS'", ",", "width", "=", "name_max_width", ")", "ret", ".", "append", "(", "self", ".", "curse_add_line", "(", "msg", ",", "\"TITLE\"", ")", ")", "# Stats", "for", "i", "in", "self", ".", "stats", ":", "# Do not display anything if no battery are detected", "if", "i", "[", "'type'", "]", "==", "'battery'", "and", "i", "[", "'value'", "]", "==", "[", "]", ":", "continue", "# New line", "ret", ".", "append", "(", "self", ".", "curse_new_line", "(", ")", ")", "msg", "=", "'{:{width}}'", ".", "format", "(", "i", "[", "\"label\"", "]", "[", ":", "name_max_width", "]", ",", "width", "=", "name_max_width", ")", "ret", ".", "append", "(", "self", ".", "curse_add_line", "(", "msg", ")", ")", "if", "i", "[", "'value'", "]", "in", "(", "b'ERR'", ",", "b'SLP'", ",", "b'UNK'", ",", "b'NOS'", ")", ":", "msg", "=", "'{:>13}'", ".", "format", "(", "i", "[", "'value'", "]", ")", "ret", ".", "append", "(", "self", ".", "curse_add_line", "(", "msg", ",", "self", ".", "get_views", "(", "item", "=", "i", "[", "self", ".", "get_key", "(", ")", "]", ",", "key", "=", "'value'", ",", "option", "=", "'decoration'", ")", ")", ")", "else", ":", "if", "(", "args", ".", "fahrenheit", "and", "i", "[", "'type'", "]", "!=", "'battery'", "and", "i", "[", "'type'", "]", "!=", "'fan_speed'", ")", ":", "value", "=", "to_fahrenheit", "(", "i", "[", "'value'", "]", ")", "unit", "=", "'F'", "else", ":", "value", "=", "i", "[", "'value'", "]", "unit", "=", "i", "[", "'unit'", "]", "try", ":", "msg", "=", "'{:>13.0f}{}'", ".", "format", "(", "value", ",", "unit", ")", "ret", ".", "append", "(", "self", ".", "curse_add_line", "(", "msg", ",", "self", ".", "get_views", "(", "item", "=", "i", "[", "self", ".", "get_key", "(", ")", "]", ",", "key", "=", "'value'", ",", "option", "=", "'decoration'", ")", ")", ")", "except", "(", "TypeError", ",", "ValueError", ")", ":", "pass", "return", "ret" ]

[ "Return", "the", "dict", "to", "display", "in", "the", "curse", "interface", "." ]

[ "def", "_growing_step_sequence", "(", "interval_growth", ",", "max_interval", ",", "init_interval", ",", "start_level", "=", "None", ")", ":", "interval", "=", "init_interval", "next_level", "=", "start_level", "or", "init_interval", "while", "True", ":", "yield", "next_level", "interval", "=", "min", "(", "interval", "*", "interval_growth", ",", "max_interval", ")", "next_level", "+=", "interval" ]

[ "Returns", "an", "iterator", "that", "constructs", "a", "sequence", "of", "trigger", "levels", "with", "growing", "intervals", ".", "The", "interval", "is", "growing", "exponentially", "until", "it", "reaches", "the", "maximum", "value", ".", "Then", "the", "interval", "stays", "the", "same", "and", "the", "sequence", "becomes", "linear", "." ]

[ "def", "avail_images", "(", "kwargs", "=", "None", ",", "call", "=", "None", ")", ":", "if", "call", "==", "'action'", ":", "raise", "SaltCloudSystemExit", "(", "'The avail_images function must be called with '", "'-f or --function, or with the --list-images option'", ")", "if", "not", "isinstance", "(", "kwargs", ",", "dict", ")", ":", "kwargs", "=", "{", "}", "params", "=", "{", "'action'", ":", "'DescribeImages'", ",", "'provider'", ":", "'system'", ",", "'zone'", ":", "_get_specified_zone", "(", "kwargs", ",", "get_configured_provider", "(", ")", ")", ",", "}", "items", "=", "query", "(", "params", "=", "params", ")", "result", "=", "{", "}", "for", "image", "in", "items", "[", "'image_set'", "]", ":", "result", "[", "image", "[", "'image_id'", "]", "]", "=", "{", "}", "for", "key", "in", "image", ":", "result", "[", "image", "[", "'image_id'", "]", "]", "[", "key", "]", "=", "image", "[", "key", "]", "return", "result" ]

[ "Return", "a", "list", "of", "the", "images", "that", "are", "on", "the", "provider", "." ]

[ "def", "scaleField", "(", "self", ",", "scalingFactor", ")", ":", "self", ".", "field_strength", "=", "self", ".", "field_strength", ".", "_replace", "(", "val", "=", "self", ".", "field_strength", ".", "val", "*", "scalingFactor", ")" ]

[ "Adjust", "the", "field", "of", "the", "magnet", "by", "the", "value", "of", "scalingFactor", ".", "The", "adjustment", "is", "multiplicative", "so", "a", "value", "of", "scalingFactor", "=", "1", ".", "0", "will", "result", "in", "no", "change", "of", "the", "field", "." ]

[ "def", "execute", "(", "self", ",", "action", ",", "parameters", ")", ":", "measurements", "=", "collections", ".", "deque", "(", "[", "]", ",", "self", ".", "_max_retries", ")", "for", "attempt", "in", "range", "(", "1", ",", "self", ".", "_max_retries", "+", "1", ")", ":", "try", ":", "result", "=", "yield", "self", ".", "_execute", "(", "action", ",", "parameters", ",", "attempt", ",", "measurements", ")", "except", "(", "exceptions", ".", "InternalServerError", ",", "exceptions", ".", "RequestException", ",", "exceptions", ".", "ThrottlingException", ",", "exceptions", ".", "ThroughputExceeded", ",", "exceptions", ".", "ServiceUnavailable", ")", "as", "error", ":", "if", "attempt", "==", "self", ".", "_max_retries", ":", "if", "self", ".", "_instrumentation_callback", ":", "self", ".", "_instrumentation_callback", "(", "measurements", ")", "self", ".", "_on_exception", "(", "error", ")", "duration", "=", "self", ".", "_sleep_duration", "(", "attempt", ")", "self", ".", "logger", ".", "warning", "(", "'%r on attempt %i, sleeping %.2f seconds'", ",", "error", ",", "attempt", ",", "duration", ")", "yield", "gen", ".", "sleep", "(", "duration", ")", "except", "exceptions", ".", "DynamoDBException", "as", "error", ":", "if", "self", ".", "_instrumentation_callback", ":", "self", ".", "_instrumentation_callback", "(", "measurements", ")", "self", ".", "_on_exception", "(", "error", ")", "else", ":", "if", "self", ".", "_instrumentation_callback", ":", "self", ".", "_instrumentation_callback", "(", "measurements", ")", "self", ".", "logger", ".", "debug", "(", "'%s result: %r'", ",", "action", ",", "result", ")", "raise", "gen", ".", "Return", "(", "_unwrap_result", "(", "action", ",", "result", ")", ")" ]

[ "Execute", "a", "DynamoDB", "action", "with", "the", "given", "parameters", ".", "The", "method", "will", "retry", "requests", "that", "failed", "due", "to", "OS", "level", "errors", "or", "when", "being", "throttled", "by", "DynamoDB", "." ]

[ "def", "query_most", "(", "num", "=", "8", ",", "kind", "=", "'1'", ")", ":", "return", "TabPost", ".", "select", "(", ")", ".", "where", "(", "(", "TabPost", ".", "kind", "==", "kind", ")", "&", "(", "TabPost", ".", "valid", "==", "1", ")", ")", ".", "order_by", "(", "TabPost", ".", "view_count", ".", "desc", "(", ")", ")", ".", "limit", "(", "num", ")" ]

[ "Query", "most", "viewed", "." ]

[ "def", "count", "(", "self", ",", "sub", ",", "start", "=", "0", ",", "end", "=", "-", "1", ")", ":", "return", "self", ".", "value_no_colors", ".", "count", "(", "sub", ",", "start", ",", "end", ")" ]

[ "Return", "the", "number", "of", "non", "-", "overlapping", "occurrences", "of", "substring", "sub", "in", "string", "[", "start", ":", "end", "]", "." ]

[ "def", "from_etree", "(", "el", ",", "node", "=", "None", ",", "node_cls", "=", "None", ",", "tagsub", "=", "functools", ".", "partial", "(", "re", ".", "sub", ",", "r'\\{.+?\\}'", ",", "''", ")", ",", "Node", "=", "Node", ")", ":", "node_cls", "=", "node_cls", "or", "Node", "if", "node", "is", "None", ":", "node", "=", "node_cls", "(", ")", "tag", "=", "tagsub", "(", "el", ".", "tag", ")", "attrib", "=", "dict", "(", "(", "tagsub", "(", "k", ")", ",", "v", ")", "for", "(", "k", ",", "v", ")", "in", "el", ".", "attrib", ".", "items", "(", ")", ")", "node", ".", "update", "(", "attrib", ",", "tag", "=", "tag", ")", "if", "el", ".", "text", ":", "node", "[", "'text'", "]", "=", "el", ".", "text", "for", "child", "in", "el", ":", "child", "=", "from_etree", "(", "child", ",", "node_cls", "=", "node_cls", ")", "node", ".", "append", "(", "child", ")", "if", "el", ".", "tail", ":", "node", "[", "'tail'", "]", "=", "el", ".", "tail", "return", "node" ]

[ "Convert", "the", "element", "tree", "to", "a", "tater", "tree", "." ]

[ "def", "jdbc_connection_pool", "(", "self", ",", "name", ",", "res_type", ",", "ds_classname", ",", "props", ")", ":", "return", "JDBCConnectionPool", "(", "self", ".", "__endpoint", ",", "name", ",", "res_type", ",", "ds_classname", ",", "props", ")" ]

[ "Domain", "JDBC", "connection", "pool", ".", ":", "param", "str", "name", ":", "Resource", "name", ".", ":", "param", "str", "res_type", ":", "Resource", "type", ".", ":", "param", "str", "ds_classname", ":", "Data", "source", "class", "name", ".", ":", "param", "dict", "props", ":", "Connection", "pool", "properties", ".", ":", "rtype", ":", "JDBCConnectionPool" ]

[ "def", "open", "(", "target", ")", ":", "if", "sys", ".", "platform", "==", "\"win32\"", ":", "os", ".", "startfile", "(", "target", ")", "else", ":", "opener", "=", "\"open\"", "if", "sys", ".", "platform", "==", "\"darwin\"", "else", "\"xdg-open\"", "subprocess", ".", "call", "(", "[", "opener", ",", "target", "]", ")" ]

[ "Opens", "the", "target", "file", "or", "URL", "in", "the", "default", "application", "." ]

[ "def", "_is_punctuation", "(", "char", ")", ":", "cp", "=", "ord", "(", "char", ")", "# We treat all non-letter/number ASCII as punctuation.", "# Characters such as \"^\", \"$\", and \"`\" are not in the Unicode", "# Punctuation class but we treat them as punctuation anyways, for", "# consistency.", "if", "(", "(", "cp", ">=", "33", "and", "cp", "<=", "47", ")", "or", "(", "cp", ">=", "58", "and", "cp", "<=", "64", ")", "or", "(", "cp", ">=", "91", "and", "cp", "<=", "96", ")", "or", "(", "cp", ">=", "123", "and", "cp", "<=", "126", ")", ")", ":", "return", "True", "cat", "=", "unicodedata", ".", "category", "(", "char", ")", "if", "cat", ".", "startswith", "(", "\"P\"", ")", ":", "return", "True", "return", "False" ]

[ "Checks", "whether", "chars", "is", "a", "punctuation", "character", "." ]

[ "def", "mach2tas", "(", "M", ",", "h", ")", ":", "a", "=", "vsound", "(", "h", ")", "tas", "=", "M", "*", "a", "return", "tas" ]

[ "True", "airspeed", "(", "tas", ")", "to", "mach", "number", "conversion" ]

[ "def", "grant_bonus", "(", "self", ",", "worker_id", ",", "assignment_id", ",", "bonus_price", ",", "reason", ")", ":", "params", "=", "bonus_price", ".", "get_as_params", "(", "'BonusAmount'", ",", "1", ")", "params", "[", "'WorkerId'", "]", "=", "worker_id", "params", "[", "'AssignmentId'", "]", "=", "assignment_id", "params", "[", "'Reason'", "]", "=", "reason", "return", "self", ".", "_process_request", "(", "'GrantBonus'", ",", "params", ")" ]

[ "Issues", "a", "payment", "of", "money", "from", "your", "account", "to", "a", "Worker", ".", "To", "be", "eligible", "for", "a", "bonus", "the", "Worker", "must", "have", "submitted", "results", "for", "one", "of", "your", "HITs", "and", "have", "had", "those", "results", "approved", "or", "rejected", ".", "This", "payment", "happens", "separately", "from", "the", "reward", "you", "pay", "to", "the", "Worker", "when", "you", "approve", "the", "Worker", "s", "assignment", ".", "The", "Bonus", "must", "be", "passed", "in", "as", "an", "instance", "of", "the", "Price", "object", "." ]

[ "def", "set_size", "(", "self", ",", "pt", "=", "None", ",", "px", "=", "None", ")", ":", "assert", "(", "pt", ",", "px", ")", "!=", "(", "None", ",", "None", ")", "if", "pt", "is", "not", "None", ":", "self", ".", "__init__", "(", "pt", ",", "self", ".", "font_name", ")", "else", ":", "self", ".", "__init__", "(", "self", ".", "px_to_pt", "(", "px", ")", ",", "self", ".", "font_name", ")" ]

[ "Set", "the", "size", "of", "the", "font", "in", "px", "or", "pt", "." ]

[ "def", "update_job_status", "(", "self", ",", "checker_func", ")", ":", "njobs", "=", "len", "(", "self", ".", "cache", ".", "keys", "(", ")", ")", "status_vect", "=", "np", ".", "zeros", "(", "(", "8", ")", ",", "int", ")", "sys", ".", "stdout", ".", "write", "(", "\"Updating status of %i jobs: \"", "%", "njobs", ")", "sys", ".", "stdout", ".", "flush", "(", ")", "for", "i", ",", "key", "in", "enumerate", "(", "self", ".", "cache", ".", "keys", "(", ")", ")", ":", "if", "i", "%", "200", "==", "0", ":", "sys", ".", "stdout", ".", "write", "(", "'.'", ")", "sys", ".", "stdout", ".", "flush", "(", ")", "job_details", "=", "self", ".", "cache", "[", "key", "]", "if", "job_details", ".", "status", "in", "[", "JobStatus", ".", "pending", ",", "JobStatus", ".", "running", "]", ":", "if", "checker_func", ":", "job_details", ".", "check_status_logfile", "(", "checker_func", ")", "job_details", ".", "update_table_row", "(", "self", ".", "_table", ",", "job_details", ".", "dbkey", "-", "1", ")", "status_vect", "[", "job_details", ".", "status", "]", "+=", "1", "sys", ".", "stdout", ".", "write", "(", "\"!\\n\"", ")", "sys", ".", "stdout", ".", "flush", "(", ")", "sys", ".", "stdout", ".", "write", "(", "\"Summary:\\n\"", ")", "sys", ".", "stdout", ".", "write", "(", "\" Unknown: %i\\n\"", "%", "status_vect", "[", "JobStatus", ".", "unknown", "]", ")", "sys", ".", "stdout", ".", "write", "(", "\" Not Ready: %i\\n\"", "%", "status_vect", "[", "JobStatus", ".", "not_ready", "]", ")", "sys", ".", "stdout", ".", "write", "(", "\" Ready: %i\\n\"", "%", "status_vect", "[", "JobStatus", ".", "ready", "]", ")", "sys", ".", "stdout", ".", "write", "(", "\" Pending: %i\\n\"", "%", "status_vect", "[", "JobStatus", ".", "pending", "]", ")", "sys", ".", "stdout", ".", "write", "(", "\" Running: %i\\n\"", "%", "status_vect", "[", "JobStatus", ".", "running", "]", ")", "sys", ".", "stdout", ".", "write", "(", "\" Done: %i\\n\"", "%", "status_vect", "[", "JobStatus", ".", "done", "]", ")", "sys", ".", "stdout", ".", "write", "(", "\" Failed: %i\\n\"", "%", "status_vect", "[", "JobStatus", ".", "failed", "]", ")", "sys", ".", "stdout", ".", "write", "(", "\" Partial: %i\\n\"", "%", "status_vect", "[", "JobStatus", ".", "partial_failed", "]", ")" ]

[ "Update", "the", "status", "of", "all", "the", "jobs", "in", "the", "archive" ]

[ "def", "get_stp_mst_detail_output_msti_port_port_hello_time", "(", "self", ",", "*", "*", "kwargs", ")", ":", "config", "=", "ET", ".", "Element", "(", "\"config\"", ")", "get_stp_mst_detail", "=", "ET", ".", "Element", "(", "\"get_stp_mst_detail\"", ")", "config", "=", "get_stp_mst_detail", "output", "=", "ET", ".", "SubElement", "(", "get_stp_mst_detail", ",", "\"output\"", ")", "msti", "=", "ET", ".", "SubElement", "(", "output", ",", "\"msti\"", ")", "instance_id_key", "=", "ET", ".", "SubElement", "(", "msti", ",", "\"instance-id\"", ")", "instance_id_key", ".", "text", "=", "kwargs", ".", "pop", "(", "'instance_id'", ")", "port", "=", "ET", ".", "SubElement", "(", "msti", ",", "\"port\"", ")", "port_hello_time", "=", "ET", ".", "SubElement", "(", "port", ",", "\"port-hello-time\"", ")", "port_hello_time", ".", "text", "=", "kwargs", ".", "pop", "(", "'port_hello_time'", ")", "callback", "=", "kwargs", ".", "pop", "(", "'callback'", ",", "self", ".", "_callback", ")", "return", "callback", "(", "config", ")" ]

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

[ "def", "setHighlightColor", "(", "self", ",", "color", ")", ":", "color", "=", "QColor", "(", "color", ")", "if", "self", ".", "_palette", "is", "None", ":", "self", ".", "_palette", "=", "XNodePalette", "(", "self", ".", "_scenePalette", ")", "self", ".", "_palette", ".", "setColor", "(", "self", ".", "_palette", ".", "NodeHighlight", ",", "color", ")", "self", ".", "setDirty", "(", ")" ]

[ "Sets", "the", "color", "to", "be", "used", "when", "highlighting", "a", "node", ".", ":", "param", "color", "<QColor", ">", "||", "None" ]

[ "def", "_series_data_filter", "(", "data", ")", ":", "data", "=", "copy", ".", "deepcopy", "(", "data", ")", "if", "\"series\"", "in", "data", ":", "for", "series", "in", "data", "[", "\"series\"", "]", ":", "series", "[", "\"data\"", "]", "=", "\"[...]\"", "return", "data" ]

[ "Replace", "each", "data", "key", "in", "the", "list", "stored", "under", "series", "by", "[", "...", "]", "." ]

[ "def", "quantile", "(", "self", ",", "axis", "=", "0", ",", "consolidate", "=", "True", ",", "transposed", "=", "False", ",", "interpolation", "=", "'linear'", ",", "qs", "=", "None", ",", "numeric_only", "=", "None", ")", ":", "# Series dispatches to DataFrame for quantile, which allows us to", "# simplify some of the code here and in the blocks", "assert", "self", ".", "ndim", ">=", "2", "if", "consolidate", ":", "self", ".", "_consolidate_inplace", "(", ")", "def", "get_axe", "(", "block", ",", "qs", ",", "axes", ")", ":", "from", "pandas", "import", "Float64Index", "if", "is_list_like", "(", "qs", ")", ":", "ax", "=", "Float64Index", "(", "qs", ")", "elif", "block", ".", "ndim", "==", "1", ":", "ax", "=", "Float64Index", "(", "[", "qs", "]", ")", "else", ":", "ax", "=", "axes", "[", "0", "]", "return", "ax", "axes", ",", "blocks", "=", "[", "]", ",", "[", "]", "for", "b", "in", "self", ".", "blocks", ":", "block", "=", "b", ".", "quantile", "(", "axis", "=", "axis", ",", "qs", "=", "qs", ",", "interpolation", "=", "interpolation", ")", "axe", "=", "get_axe", "(", "b", ",", "qs", ",", "axes", "=", "self", ".", "axes", ")", "axes", ".", "append", "(", "axe", ")", "blocks", ".", "append", "(", "block", ")", "# note that some DatetimeTZ, Categorical are always ndim==1", "ndim", "=", "{", "b", ".", "ndim", "for", "b", "in", "blocks", "}", "assert", "0", "not", "in", "ndim", ",", "ndim", "if", "2", "in", "ndim", ":", "new_axes", "=", "list", "(", "self", ".", "axes", ")", "# multiple blocks that are reduced", "if", "len", "(", "blocks", ")", ">", "1", ":", "new_axes", "[", "1", "]", "=", "axes", "[", "0", "]", "# reset the placement to the original", "for", "b", ",", "sb", "in", "zip", "(", "blocks", ",", "self", ".", "blocks", ")", ":", "b", ".", "mgr_locs", "=", "sb", ".", "mgr_locs", "else", ":", "new_axes", "[", "axis", "]", "=", "Index", "(", "np", ".", "concatenate", "(", "[", "ax", ".", "values", "for", "ax", "in", "axes", "]", ")", ")", "if", "transposed", ":", "new_axes", "=", "new_axes", "[", ":", ":", "-", "1", "]", "blocks", "=", "[", "b", ".", "make_block", "(", "b", ".", "values", ".", "T", ",", "placement", "=", "np", ".", "arange", "(", "b", ".", "shape", "[", "1", "]", ")", ")", "for", "b", "in", "blocks", "]", "return", "self", ".", "__class__", "(", "blocks", ",", "new_axes", ")", "# single block, i.e. ndim == {1}", "values", "=", "_concat", ".", "_concat_compat", "(", "[", "b", ".", "values", "for", "b", "in", "blocks", "]", ")", "# compute the orderings of our original data", "if", "len", "(", "self", ".", "blocks", ")", ">", "1", ":", "indexer", "=", "np", ".", "empty", "(", "len", "(", "self", ".", "axes", "[", "0", "]", ")", ",", "dtype", "=", "np", ".", "intp", ")", "i", "=", "0", "for", "b", "in", "self", ".", "blocks", ":", "for", "j", "in", "b", ".", "mgr_locs", ":", "indexer", "[", "j", "]", "=", "i", "i", "=", "i", "+", "1", "values", "=", "values", ".", "take", "(", "indexer", ")", "return", "SingleBlockManager", "(", "[", "make_block", "(", "values", ",", "ndim", "=", "1", ",", "placement", "=", "np", ".", "arange", "(", "len", "(", "values", ")", ")", ")", "]", ",", "axes", "[", "0", "]", ")" ]

[ "Iterate", "over", "blocks", "applying", "quantile", "reduction", ".", "This", "routine", "is", "intended", "for", "reduction", "type", "operations", "and", "will", "do", "inference", "on", "the", "generated", "blocks", "." ]

[ "def", "_get_algorithm_and_params", "(", "self", ",", "algorithm_name", ",", "algorithm_params", ")", ":", "algorithm_name", "=", "algorithm_name", "or", "CORRELATOR_ALGORITHM", "try", ":", "self", ".", "algorithm", "=", "correlator_algorithms", "[", "algorithm_name", "]", "except", "KeyError", ":", "raise", "exceptions", ".", "AlgorithmNotFound", "(", "'luminol.Correlator: '", "+", "str", "(", "algorithm_name", ")", "+", "' not found.'", ")", "# Merge parameters.", "if", "algorithm_params", ":", "if", "not", "isinstance", "(", "algorithm_params", ",", "dict", ")", ":", "raise", "exceptions", ".", "InvalidDataFormat", "(", "'luminol.Correlator: algorithm_params passed is not a dictionary.'", ")", "else", ":", "# self.algorithm_params = dict(algorithm_params.items() + self.algorithm_params.items())", "self", ".", "algorithm_params", "=", "self", ".", "algorithm_params", ".", "copy", "(", ")", "self", ".", "algorithm_params", ".", "update", "(", "algorithm_params", ")" ]

[ "Get", "the", "specific", "algorithm", "and", "merge", "the", "algorithm", "params", ".", ":", "param", "str", "algorithm", ":", "name", "of", "the", "algorithm", "to", "use", ".", ":", "param", "dict", "algorithm_params", ":", "additional", "params", "for", "the", "specific", "algorithm", "." ]