Datasets:

sia-precision-education

/

pile_python

like 3

[]

[ "def", "buildTree", "(", "self", ",", "preorder", ",", "inorder", ")", ":", "if", "len", "(", "inorder", ")", "==", "0", ":", "return", "None", "else", ":", "root_val", "=", "preorder", ".", "pop", "(", "0", ")", "root_index", "=", "inorder", ".", "index", "(", "root_val", ")", "left_tree", "=", "self", ".", "buildTree", "(", "preorder", ",", "inorder", "[", ":", "root_index", "]", ")", "right_tree", "=", "self", ".", "buildTree", "(", "preorder", ",", "inorder", "[", "root_index", "+", "1", ":", "]", ")", "root", "=", "TreeNode", "(", "root_val", ")", "root", ".", "left", "=", "left_tree", "root", ".", "right", "=", "right_tree", "return", "root" ]

[ "Deduce", "the", "encoding", "of", "a", "Python", "source", "file", "(", "binary", "mode", ")", "from", "magic", "comment", "." ]

[ "def", "parse_encoding", "(", "fp", ")", ":", "pos", "=", "fp", ".", "tell", "(", ")", "fp", ".", "seek", "(", "0", ")", "try", ":", "line1", "=", "fp", ".", "readline", "(", ")", "has_bom", "=", "line1", ".", "startswith", "(", "codecs", ".", "BOM_UTF8", ")", "if", "has_bom", ":", "line1", "=", "line1", "[", "len", "(", "codecs", ".", "BOM_UTF8", ")", ":", "]", "m", "=", "_PYTHON_MAGIC_COMMENT_re", ".", "match", "(", "line1", ".", "decode", "(", "\"ascii\"", ",", "\"ignore\"", ")", ")", "if", "not", "m", ":", "try", ":", "parse", "(", "line1", ".", "decode", "(", "\"ascii\"", ",", "\"ignore\"", ")", ")", "except", "(", "ImportError", ",", "SyntaxError", ")", ":", "# Either it's a real syntax error, in which case the source", "# is not valid python source, or line2 is a continuation of", "# line1, in which case we don't want to scan line2 for a magic", "# comment.", "pass", "else", ":", "line2", "=", "fp", ".", "readline", "(", ")", "m", "=", "_PYTHON_MAGIC_COMMENT_re", ".", "match", "(", "line2", ".", "decode", "(", "\"ascii\"", ",", "\"ignore\"", ")", ")", "if", "has_bom", ":", "if", "m", ":", "raise", "SyntaxError", "(", "\"python refuses to compile code with both a UTF8\"", "\" byte-order-mark and a magic encoding comment\"", ")", "return", "\"utf_8\"", "elif", "m", ":", "return", "m", ".", "group", "(", "1", ")", "else", ":", "return", "None", "finally", ":", "fp", ".", "seek", "(", "pos", ")" ]

[ "Close", "all", "pool", "connections", "and", "shutdown", "the", "pool", "." ]

[ "def", "close", "(", "self", ")", ":", "if", "self", ".", "shutdownID", ":", "self", ".", "_reactor", ".", "removeSystemEventTrigger", "(", "self", ".", "shutdownID", ")", "self", ".", "shutdownID", "=", "None", "if", "self", ".", "startID", ":", "self", ".", "_reactor", ".", "removeSystemEventTrigger", "(", "self", ".", "startID", ")", "self", ".", "startID", "=", "None", "self", ".", "finalClose", "(", ")" ]

[ "True", "if", "col", "is", "an", "instance", "of", ":", "class", ":", ".", "ColumnElement", "." ]

[ "def", "_is_column", "(", "col", ")", ":", "return", "isinstance", "(", "col", ",", "ColumnElement", ")" ]

[ "Merge", "the", "data", "from", "the", "optimization", "checks", "file" ]

[ "def", "process_optimization_results", "(", "self", ",", "page_data", ",", "requests", ",", "optimization_results", ")", ":", "if", "optimization_results", "and", "not", "self", ".", "must_exit", ":", "page_data", "[", "'score_cache'", "]", "=", "-", "1", "page_data", "[", "'score_cdn'", "]", "=", "-", "1", "page_data", "[", "'score_gzip'", "]", "=", "-", "1", "page_data", "[", "'score_cookies'", "]", "=", "-", "1", "page_data", "[", "'score_keep-alive'", "]", "=", "-", "1", "page_data", "[", "'score_minify'", "]", "=", "-", "1", "page_data", "[", "'score_combine'", "]", "=", "-", "1", "page_data", "[", "'score_compress'", "]", "=", "-", "1", "page_data", "[", "'score_etags'", "]", "=", "-", "1", "page_data", "[", "'score_progressive_jpeg'", "]", "=", "-", "1", "page_data", "[", "'gzip_total'", "]", "=", "0", "page_data", "[", "'gzip_savings'", "]", "=", "0", "page_data", "[", "'minify_total'", "]", "=", "-", "1", "page_data", "[", "'minify_savings'", "]", "=", "-", "1", "page_data", "[", "'image_total'", "]", "=", "0", "page_data", "[", "'image_savings'", "]", "=", "0", "page_data", "[", "'optimization_checked'", "]", "=", "1", "page_data", "[", "'base_page_cdn'", "]", "=", "''", "cache_count", "=", "0", "cache_total", "=", "0", "cdn_count", "=", "0", "cdn_total", "=", "0", "keep_alive_count", "=", "0", "keep_alive_total", "=", "0", "progressive_total_bytes", "=", "0", "progressive_bytes", "=", "0", "for", "request", "in", "requests", ":", "if", "request", "[", "'responseCode'", "]", "==", "200", ":", "request_id", "=", "str", "(", "request", "[", "'id'", "]", ")", "pos", "=", "request_id", ".", "find", "(", "'-'", ")", "if", "pos", ">", "0", ":", "request_id", "=", "request_id", "[", ":", "pos", "]", "if", "request_id", "in", "optimization_results", ":", "opt", "=", "optimization_results", "[", "request_id", "]", "if", "'cache'", "in", "opt", ":", "request", "[", "'score_cache'", "]", "=", "opt", "[", "'cache'", "]", "[", "'score'", "]", "request", "[", "'cache_time'", "]", "=", "opt", "[", "'cache'", "]", "[", "'time'", "]", "cache_count", "+=", "1", "cache_total", "+=", "request", "[", "'score_cache'", "]", "if", "'cdn'", "in", "opt", ":", "request", "[", "'score_cdn'", "]", "=", "opt", "[", "'cdn'", "]", "[", "'score'", "]", "request", "[", "'cdn_provider'", "]", "=", "opt", "[", "'cdn'", "]", "[", "'provider'", "]", "cdn_count", "+=", "1", "cdn_total", "+=", "request", "[", "'score_cdn'", "]", "if", "'is_base_page'", "in", "request", "and", "request", "[", "'is_base_page'", "]", "and", "request", "[", "'cdn_provider'", "]", "is", "not", "None", ":", "page_data", "[", "'base_page_cdn'", "]", "=", "request", "[", "'cdn_provider'", "]", "if", "'keep_alive'", "in", "opt", ":", "request", "[", "'score_keep-alive'", "]", "=", "opt", "[", "'keep_alive'", "]", "[", "'score'", "]", "keep_alive_count", "+=", "1", "keep_alive_total", "+=", "request", "[", "'score_keep-alive'", "]", "if", "'gzip'", "in", "opt", ":", "savings", "=", "opt", "[", "'gzip'", "]", "[", "'size'", "]", "-", "opt", "[", "'gzip'", "]", "[", "'target_size'", "]", "request", "[", "'score_gzip'", "]", "=", "opt", "[", "'gzip'", "]", "[", "'score'", "]", "request", "[", "'gzip_total'", "]", "=", "opt", "[", "'gzip'", "]", "[", "'size'", "]", "request", "[", "'gzip_save'", "]", "=", "savings", "page_data", "[", "'gzip_total'", "]", "+=", "opt", "[", "'gzip'", "]", "[", "'size'", "]", "page_data", "[", "'gzip_savings'", "]", "+=", "savings", "if", "'image'", "in", "opt", ":", "savings", "=", "opt", "[", "'image'", "]", "[", "'size'", "]", "-", "opt", "[", "'image'", "]", "[", "'target_size'", "]", "request", "[", "'score_compress'", "]", "=", "opt", "[", "'image'", "]", "[", "'score'", "]", "request", "[", "'image_total'", "]", "=", "opt", "[", "'image'", "]", "[", "'size'", "]", "request", "[", "'image_save'", "]", "=", "savings", "page_data", "[", "'image_total'", "]", "+=", "opt", "[", "'image'", "]", "[", "'size'", "]", "page_data", "[", "'image_savings'", "]", "+=", "savings", "if", "'progressive'", "in", "opt", ":", "size", "=", "opt", "[", "'progressive'", "]", "[", "'size'", "]", "request", "[", "'jpeg_scan_count'", "]", "=", "opt", "[", "'progressive'", "]", "[", "'scan_count'", "]", "progressive_total_bytes", "+=", "size", "if", "request", "[", "'jpeg_scan_count'", "]", ">", "1", ":", "request", "[", "'score_progressive_jpeg'", "]", "=", "100", "progressive_bytes", "+=", "size", "elif", "size", "<", "10240", ":", "request", "[", "'score_progressive_jpeg'", "]", "=", "50", "else", ":", "request", "[", "'score_progressive_jpeg'", "]", "=", "0", "if", "cache_count", ">", "0", ":", "page_data", "[", "'score_cache'", "]", "=", "int", "(", "round", "(", "cache_total", "/", "cache_count", ")", ")", "if", "cdn_count", ">", "0", ":", "page_data", "[", "'score_cdn'", "]", "=", "int", "(", "round", "(", "cdn_total", "/", "cdn_count", ")", ")", "if", "keep_alive_count", ">", "0", ":", "page_data", "[", "'score_keep-alive'", "]", "=", "int", "(", "round", "(", "keep_alive_total", "/", "keep_alive_count", ")", ")", "if", "page_data", "[", "'gzip_total'", "]", ">", "0", ":", "page_data", "[", "'score_gzip'", "]", "=", "100", "-", "int", "(", "page_data", "[", "'gzip_savings'", "]", "*", "100", "/", "page_data", "[", "'gzip_total'", "]", ")", "if", "page_data", "[", "'image_total'", "]", ">", "0", ":", "page_data", "[", "'score_compress'", "]", "=", "100", "-", "int", "(", "page_data", "[", "'image_savings'", "]", "*", "100", "/", "page_data", "[", "'image_total'", "]", ")", "if", "progressive_total_bytes", ">", "0", ":", "page_data", "[", "'score_progressive_jpeg'", "]", "=", "int", "(", "round", "(", "progressive_bytes", "*", "100", "/", "progressive_total_bytes", ")", ")" ]

[ "Initializes", "the", "instance", "-", "basically", "setting", "the", "formatter", "to", "None", "and", "the", "filter", "list", "to", "empty", "." ]

[ "def", "__init__", "(", "self", ",", "level", "=", "NOTSET", ")", ":", "Filterer", ".", "__init__", "(", "self", ")", "self", ".", "_name", "=", "None", "self", ".", "level", "=", "_checkLevel", "(", "level", ")", "self", ".", "formatter", "=", "None", "# Add the handler to the global _handlerList (for cleanup on shutdown)", "_addHandlerRef", "(", "self", ")", "self", ".", "createLock", "(", ")" ]

[ "Check", "the", "validity", "of", "a", "linkage", "matrix", "." ]

[ "def", "is_valid_linkage", "(", "Z", ",", "warning", "=", "False", ",", "throw", "=", "False", ",", "name", "=", "None", ")", ":", "Z", "=", "np", ".", "asarray", "(", "Z", ",", "order", "=", "'c'", ")", "valid", "=", "True", "name_str", "=", "\"%r \"", "%", "name", "if", "name", "else", "''", "try", ":", "if", "type", "(", "Z", ")", "!=", "np", ".", "ndarray", ":", "raise", "TypeError", "(", "'Passed linkage argument %sis not a valid array.'", "%", "name_str", ")", "if", "Z", ".", "dtype", "!=", "np", ".", "double", ":", "raise", "TypeError", "(", "'Linkage matrix %smust contain doubles.'", "%", "name_str", ")", "if", "len", "(", "Z", ".", "shape", ")", "!=", "2", ":", "raise", "ValueError", "(", "'Linkage matrix %smust have shape=2 (i.e. be '", "'two-dimensional).'", "%", "name_str", ")", "if", "Z", ".", "shape", "[", "1", "]", "!=", "4", ":", "raise", "ValueError", "(", "'Linkage matrix %smust have 4 columns.'", "%", "name_str", ")", "if", "Z", ".", "shape", "[", "0", "]", "==", "0", ":", "raise", "ValueError", "(", "'Linkage must be computed on at least two '", "'observations.'", ")", "n", "=", "Z", ".", "shape", "[", "0", "]", "if", "n", ">", "1", ":", "if", "(", "(", "Z", "[", ":", ",", "0", "]", "<", "0", ")", ".", "any", "(", ")", "or", "(", "Z", "[", ":", ",", "1", "]", "<", "0", ")", ".", "any", "(", ")", ")", ":", "raise", "ValueError", "(", "'Linkage %scontains negative indices.'", "%", "name_str", ")", "if", "(", "Z", "[", ":", ",", "2", "]", "<", "0", ")", ".", "any", "(", ")", ":", "raise", "ValueError", "(", "'Linkage %scontains negative distances.'", "%", "name_str", ")", "if", "(", "Z", "[", ":", ",", "3", "]", "<", "0", ")", ".", "any", "(", ")", ":", "raise", "ValueError", "(", "'Linkage %scontains negative counts.'", "%", "name_str", ")", "if", "_check_hierarchy_uses_cluster_before_formed", "(", "Z", ")", ":", "raise", "ValueError", "(", "'Linkage %suses non-singleton cluster before '", "'it is formed.'", "%", "name_str", ")", "if", "_check_hierarchy_uses_cluster_more_than_once", "(", "Z", ")", ":", "raise", "ValueError", "(", "'Linkage %suses the same cluster more than once.'", "%", "name_str", ")", "except", "Exception", "as", "e", ":", "if", "throw", ":", "raise", "if", "warning", ":", "_warning", "(", "str", "(", "e", ")", ")", "valid", "=", "False", "return", "valid" ]

[]

[ "def", "PyJs_anonymous_1425_", "(", "require", ",", "module", ",", "exports", ",", "this", ",", "arguments", ",", "var", "=", "var", ")", ":", "var", "=", "Scope", "(", "{", "u'this'", ":", "this", ",", "u'require'", ":", "require", ",", "u'exports'", ":", "exports", ",", "u'module'", ":", "module", ",", "u'arguments'", ":", "arguments", "}", ",", "var", ")", "var", ".", "registers", "(", "[", "u'require'", ",", "u'exports'", ",", "u'module'", "]", ")", "var", ".", "get", "(", "u'require'", ")", "(", "Js", "(", "u'../modules/es6.object.to-string'", ")", ")", "var", ".", "get", "(", "u'require'", ")", "(", "Js", "(", "u'../modules/web.dom.iterable'", ")", ")", "var", ".", "get", "(", "u'require'", ")", "(", "Js", "(", "u'../modules/es6.weak-map'", ")", ")", "var", ".", "get", "(", "u'module'", ")", ".", "put", "(", "u'exports'", ",", "var", ".", "get", "(", "u'require'", ")", "(", "Js", "(", "u'../modules/_core'", ")", ")", ".", "get", "(", "u'WeakMap'", ")", ")" ]

[ "Sets", "the", "path", "and", "encoder", "codec", "to", "use", "when", "exporting", "videos", "." ]

[ "def", "set_output", "(", "self", ",", "scan_only", "=", "True", ",", "comp_file", "=", "None", ",", "codec", "=", "'XVID'", ",", "draw_timecode", "=", "False", ")", ":", "# type: (bool, str, str) -> None", "self", ".", "_scan_only", "=", "scan_only", "self", ".", "_comp_file", "=", "comp_file", "if", "len", "(", "codec", ")", "!=", "4", ":", "raise", "ValueError", "(", "\"codec must be exactly four (4) characters\"", ")", "self", ".", "_fourcc", "=", "cv2", ".", "VideoWriter_fourcc", "(", "*", "codec", ".", "upper", "(", ")", ")", "self", ".", "_draw_timecode", "=", "draw_timecode" ]

[]

[ "def", "sort_attrs", "(", "attr", ")", ":", "if", "isinstance", "(", "attr", ",", "(", "list", ",", "tuple", ")", ")", ":", "a", "=", "attr", "[", "0", "]", ".", "split", "(", "'.'", ")", "else", ":", "a", "=", "attr", ".", "split", "(", "'.'", ")", "return", "len", "(", "a", ")", ",", "a" ]

[ "Initializer" ]

[ "def", "__init__", "(", "self", ",", "console_level", "=", "logging", ".", "INFO", ",", "filename", "=", "None", ",", "file_level", "=", "logging", ".", "DEBUG", ",", "no_backups", "=", "5", ")", ":", "# Initialize the base class, the minimal level makes sure no", "# logs are missed", "super", "(", "Logger", ",", "self", ")", ".", "__init__", "(", "self", ",", "level", "=", "min", "(", "console_level", ",", "file_level", ")", ")", "# Setup console logging", "def", "expand_format_tags", "(", "message", ",", "use_color", "=", "True", ")", ":", "\"\"\"Expands $*SEQ tags in a string. If use_color is False, removes\n the tags.\n \"\"\"", "if", "use_color", ":", "message", "=", "message", ".", "replace", "(", "\"$RESET\"", ",", "printers", ".", "RESET_SEQ", ")", ".", "replace", "(", "\"$BOLD\"", ",", "printers", ".", "COLORS", "[", "'bold'", "]", ")", "else", ":", "message", "=", "message", ".", "replace", "(", "\"$RESET\"", ",", "\"\"", ")", ".", "replace", "(", "\"$BOLD\"", ",", "\"\"", ")", "return", "message", "color_formatter", "=", "ColorFormatter", "(", "expand_format_tags", "(", "CONSOLE_FORMAT", ",", "True", ")", ")", "console_handler", "=", "CONSOLE_STREAM_HANDLER", "console_handler", ".", "setLevel", "(", "console_level", ")", "console_handler", ".", "setFormatter", "(", "color_formatter", ")", "self", ".", "addHandler", "(", "console_handler", ")", "# If needed add file handler", "if", "filename", "is", "not", "None", ":", "self", ".", "addHandler", "(", "MPRotLogHandler", "(", "filename", "=", "filename", ",", "level", "=", "file_level", ",", "no_backups", "=", "no_backups", ")", ")", "# Emit the messages saved by the pre-init logger", "for", "logg", "in", "PreInitLogHandler", ".", "get_instance", "(", ")", ".", "pre_init_logs", ":", "for", "handler", "in", "self", ".", "handlers", ":", "if", "logg", ".", "levelno", ">=", "handler", ".", "level", ":", "handler", ".", "emit", "(", "logg", ")", "PreInitLogHandler", ".", "reset_instance", "(", ")" ]

[ "Gets", "an", "entry", "by", "key", ".", "Will", "return", "None", "if", "there", "is", "no", "matching", "entry", "." ]

[ "def", "get", "(", "self", ",", "entry", ")", ":", "try", ":", "list_", "=", "self", ".", "cache", "[", "entry", ".", "key", "]", "for", "cached_entry", "in", "list_", ":", "if", "entry", ".", "__eq__", "(", "cached_entry", ")", ":", "return", "cached_entry", "except", "(", "KeyError", ",", "ValueError", ")", ":", "return", "None" ]

[]

[ "def", "restore_event", "(", "self", ",", "event", "=", "None", ")", ":", "self", ".", "text", ".", "tag_delete", "(", "\"paren\"", ")", "self", ".", "deactivate_restore", "(", ")", "self", ".", "counter", "+=", "1" ]

[ "Helper", "function", "that", "computes", "transformation", "for", "keys", "and", "values", "." ]

[ "def", "_compute_edge_transforms", "(", "node_states", ",", "depth", ",", "num_transforms", ",", "name", "=", "\"transform\"", ")", ":", "node_shapes", "=", "common_layers", ".", "shape_list", "(", "node_states", ")", "x", "=", "common_layers", ".", "dense", "(", "node_states", ",", "depth", "*", "num_transforms", ",", "use_bias", "=", "False", ",", "name", "=", "name", ")", "batch", "=", "node_shapes", "[", "0", "]", "# B.", "length", "=", "node_shapes", "[", "1", "]", "# N.", "# Making the fourth dimension explicit by separating the vectors of size", "# K*T (in k) and V*T (in v) into two-dimensional matrices with shape [K, T]", "# (in k) and [V, T] in v.", "#", "x", "=", "tf", ".", "reshape", "(", "x", ",", "[", "batch", ",", "length", ",", "num_transforms", ",", "depth", "]", ")", "# Flatten out the fourth dimension.", "x", "=", "tf", ".", "reshape", "(", "x", ",", "[", "batch", ",", "length", "*", "num_transforms", ",", "depth", "]", ")", "return", "x" ]

[ "Factory", "method", "for", "OpenSUSE", "installs", "." ]

[ "def", "get_class", "(", "tdl", ",", "config", ",", "auto", ",", "output_disk", "=", "None", ",", "netdev", "=", "None", ",", "diskbus", "=", "None", ",", "macaddress", "=", "None", ")", ":", "if", "tdl", ".", "update", "in", "version_to_config", ".", "keys", "(", ")", ":", "return", "OpenSUSEGuest", "(", "tdl", ",", "config", ",", "auto", ",", "output_disk", ",", "netdev", ",", "diskbus", ",", "macaddress", ")" ]

[ "Describes", "a", "delta", "within", "multiple", "timeframes", "in", "plain", "language", ".", "In", "Hebrew", "the", "and", "word", "behaves", "a", "bit", "differently", "." ]

[ "def", "describe_multi", "(", "self", ",", "timeframes", ":", "Sequence", "[", "Tuple", "[", "TimeFrameLiteral", ",", "Union", "[", "int", ",", "float", "]", "]", "]", ",", "only_distance", ":", "bool", "=", "False", ",", ")", "->", "str", ":", "humanized", "=", "\"\"", "for", "index", ",", "(", "timeframe", ",", "delta", ")", "in", "enumerate", "(", "timeframes", ")", ":", "last_humanized", "=", "self", ".", "_format_timeframe", "(", "timeframe", ",", "trunc", "(", "delta", ")", ")", "if", "index", "==", "0", ":", "humanized", "=", "last_humanized", "elif", "index", "==", "len", "(", "timeframes", ")", "-", "1", ":", "# Must have at least 2 items", "humanized", "+=", "\" \"", "+", "self", ".", "and_word", "if", "last_humanized", "[", "0", "]", ".", "isdecimal", "(", ")", ":", "humanized", "+=", "\"־\"", "humanized", "+=", "last_humanized", "else", ":", "# Don't add for the last one", "humanized", "+=", "\", \"", "+", "last_humanized", "if", "not", "only_distance", ":", "humanized", "=", "self", ".", "_format_relative", "(", "humanized", ",", "timeframe", ",", "trunc", "(", "delta", ")", ")", "return", "humanized" ]

[ "Return", "the", "default", "value", "of", "the", "named", "info", ".", "FOO_PATH", "attribute", "even", "if", "it", "s", "been", "modified" ]

[ "def", "get_default_path", "(", "varname", ")", ":", "return", "_path_defaults", ".", "get", "(", "varname", ",", "None", ")" ]

[ "Construct", "the", "Compose", "class", "." ]

[ "def", "__init__", "(", "self", ",", "transforms", ")", ":", "self", ".", "transforms", "=", "transforms" ]

[ "Initialise", "the", "binary_sensor", "." ]

[ "def", "__init__", "(", "self", ",", "api", ",", "coordinator", ",", "name", ",", "dev_id", ",", "binary_sensor", ")", ":", "super", "(", ")", ".", "__init__", "(", "api", ",", "coordinator", ",", "name", ",", "dev_id", ")", "self", ".", "_binary_sensor", "=", "binary_sensor", "self", ".", "_icon", "=", "None", "self", ".", "_is_on", "=", "False", "if", "dev_id", "==", "self", ".", "_api", ".", "heater_id", ":", "self", ".", "_entity_name", "=", "\"Auxiliary\"", "sensorname", "=", "binary_sensor", ".", "replace", "(", "\"_\"", ",", "\" \"", ")", ".", "title", "(", ")", "self", ".", "_name", "=", "f\"{self._entity_name} {sensorname}\"", "if", "dev_id", "==", "self", ".", "_api", ".", "gateway_id", ":", "self", ".", "_entity_name", "=", "f\"Smile {self._entity_name}\"", "self", ".", "_unique_id", "=", "f\"{dev_id}-{binary_sensor}\"" ]

[ "Extract", "all", "members", "from", "the", "archive", "to", "the", "current", "working", "directory", "and", "set", "owner", "modification", "time", "and", "permissions", "on", "directories", "afterwards", ".", "path", "specifies", "a", "different", "directory", "to", "extract", "to", ".", "members", "is", "optional", "and", "must", "be", "a", "subset", "of", "the", "list", "returned", "by", "getmembers", "()", "." ]

[ "def", "extractall", "(", "self", ",", "path", "=", "\".\"", ",", "members", "=", "None", ")", ":", "directories", "=", "[", "]", "if", "members", "is", "None", ":", "members", "=", "self", "for", "tarinfo", "in", "members", ":", "if", "tarinfo", ".", "isdir", "(", ")", ":", "# Extract directories with a safe mode.", "directories", ".", "append", "(", "tarinfo", ")", "tarinfo", "=", "copy", ".", "copy", "(", "tarinfo", ")", "tarinfo", ".", "mode", "=", "0o700", "# Do not set_attrs directories, as we will do that further down", "self", ".", "extract", "(", "tarinfo", ",", "path", ",", "set_attrs", "=", "not", "tarinfo", ".", "isdir", "(", ")", ")", "# Reverse sort directories.", "directories", ".", "sort", "(", "key", "=", "lambda", "a", ":", "a", ".", "name", ")", "directories", ".", "reverse", "(", ")", "# Set correct owner, mtime and filemode on directories.", "for", "tarinfo", "in", "directories", ":", "dirpath", "=", "os", ".", "path", ".", "join", "(", "path", ",", "tarinfo", ".", "name", ")", "try", ":", "self", ".", "chown", "(", "tarinfo", ",", "dirpath", ")", "self", ".", "utime", "(", "tarinfo", ",", "dirpath", ")", "self", ".", "chmod", "(", "tarinfo", ",", "dirpath", ")", "except", "ExtractError", "as", "e", ":", "if", "self", ".", "errorlevel", ">", "1", ":", "raise", "else", ":", "self", ".", "_dbg", "(", "1", ",", "\"tarfile: %s\"", "%", "e", ")" ]

[ "perform", "the", "idempotent", "crud", "operations" ]

[ "def", "run_ansible", "(", "params", ")", ":", "yamlfile", "=", "Yedit", "(", "filename", "=", "params", "[", "'src'", "]", ",", "backup", "=", "params", "[", "'backup'", "]", ",", "content_type", "=", "params", "[", "'content_type'", "]", ",", "backup_ext", "=", "params", "[", "'backup_ext'", "]", ",", "separator", "=", "params", "[", "'separator'", "]", ")", "state", "=", "params", "[", "'state'", "]", "if", "params", "[", "'src'", "]", ":", "rval", "=", "yamlfile", ".", "load", "(", ")", "if", "yamlfile", ".", "yaml_dict", "is", "None", "and", "state", "!=", "'present'", ":", "return", "{", "'failed'", ":", "True", ",", "'msg'", ":", "'Error opening file [{}]. Verify that the '", ".", "format", "(", "params", "[", "'src'", "]", ")", "+", "'file exists, that it is has correct permissions, and is valid yaml.'", "}", "if", "state", "==", "'list'", ":", "if", "params", "[", "'content'", "]", ":", "content", "=", "Yedit", ".", "parse_value", "(", "params", "[", "'content'", "]", ",", "params", "[", "'content_type'", "]", ")", "yamlfile", ".", "yaml_dict", "=", "content", "if", "params", "[", "'key'", "]", ":", "rval", "=", "yamlfile", ".", "get", "(", "params", "[", "'key'", "]", ")", "return", "{", "'changed'", ":", "False", ",", "'result'", ":", "rval", ",", "'state'", ":", "state", "}", "elif", "state", "==", "'absent'", ":", "if", "params", "[", "'content'", "]", ":", "content", "=", "Yedit", ".", "parse_value", "(", "params", "[", "'content'", "]", ",", "params", "[", "'content_type'", "]", ")", "yamlfile", ".", "yaml_dict", "=", "content", "if", "params", "[", "'update'", "]", ":", "rval", "=", "yamlfile", ".", "pop", "(", "params", "[", "'key'", "]", ",", "params", "[", "'value'", "]", ")", "else", ":", "rval", "=", "yamlfile", ".", "delete", "(", "params", "[", "'key'", "]", ",", "params", "[", "'index'", "]", ",", "params", "[", "'value'", "]", ")", "if", "rval", "[", "0", "]", "and", "params", "[", "'src'", "]", ":", "yamlfile", ".", "write", "(", ")", "return", "{", "'changed'", ":", "rval", "[", "0", "]", ",", "'result'", ":", "rval", "[", "1", "]", ",", "'state'", ":", "state", "}", "elif", "state", "==", "'present'", ":", "# check if content is different than what is in the file", "if", "params", "[", "'content'", "]", ":", "content", "=", "Yedit", ".", "parse_value", "(", "params", "[", "'content'", "]", ",", "params", "[", "'content_type'", "]", ")", "# We had no edits to make and the contents are the same", "if", "yamlfile", ".", "yaml_dict", "==", "content", "and", "params", "[", "'value'", "]", "is", "None", ":", "return", "{", "'changed'", ":", "False", ",", "'result'", ":", "yamlfile", ".", "yaml_dict", ",", "'state'", ":", "state", "}", "yamlfile", ".", "yaml_dict", "=", "content", "# If we were passed a key, value then", "# we enapsulate it in a list and process it", "# Key, Value passed to the module : Converted to Edits list #", "edits", "=", "[", "]", "_edit", "=", "{", "}", "if", "params", "[", "'value'", "]", "is", "not", "None", ":", "_edit", "[", "'value'", "]", "=", "params", "[", "'value'", "]", "_edit", "[", "'value_type'", "]", "=", "params", "[", "'value_type'", "]", "_edit", "[", "'key'", "]", "=", "params", "[", "'key'", "]", "if", "params", "[", "'update'", "]", ":", "_edit", "[", "'action'", "]", "=", "'update'", "_edit", "[", "'curr_value'", "]", "=", "params", "[", "'curr_value'", "]", "_edit", "[", "'curr_value_format'", "]", "=", "params", "[", "'curr_value_format'", "]", "_edit", "[", "'index'", "]", "=", "params", "[", "'index'", "]", "elif", "params", "[", "'append'", "]", ":", "_edit", "[", "'action'", "]", "=", "'append'", "edits", ".", "append", "(", "_edit", ")", "elif", "params", "[", "'edits'", "]", "is", "not", "None", ":", "edits", "=", "params", "[", "'edits'", "]", "if", "edits", ":", "results", "=", "Yedit", ".", "process_edits", "(", "edits", ",", "yamlfile", ")", "# if there were changes and a src provided to us we need to write", "if", "results", "[", "'changed'", "]", "and", "params", "[", "'src'", "]", ":", "yamlfile", ".", "write", "(", ")", "return", "{", "'changed'", ":", "results", "[", "'changed'", "]", ",", "'result'", ":", "results", "[", "'results'", "]", ",", "'state'", ":", "state", "}", "# no edits to make", "if", "params", "[", "'src'", "]", ":", "# pylint: disable=redefined-variable-type", "rval", "=", "yamlfile", ".", "write", "(", ")", "return", "{", "'changed'", ":", "rval", "[", "0", "]", ",", "'result'", ":", "rval", "[", "1", "]", ",", "'state'", ":", "state", "}", "# We were passed content but no src, key or value, or edits. Return contents in memory", "return", "{", "'changed'", ":", "False", ",", "'result'", ":", "yamlfile", ".", "yaml_dict", ",", "'state'", ":", "state", "}", "return", "{", "'failed'", ":", "True", ",", "'msg'", ":", "'Unkown state passed'", "}" ]

[ "get", "a", "key" ]

[ "def", "get", "(", "self", ",", "context", ",", "key_id", ",", "*", "*", "kwargs", ")", ":", "return", "key", ".", "Passphrase", "(", "passphrase", "=", "key_id", ")" ]

[ "Return", "the", "inverse", "of", "the", "permutation", "." ]

[ "def", "__invert__", "(", "self", ")", ":", "return", "_af_new", "(", "_af_invert", "(", "self", ".", "_array_form", ")", ")" ]

[ "Get", "the", "documentation", "string", "for", "an", "object", "." ]

[ "def", "getdoc", "(", "object", ")", ":", "try", ":", "doc", "=", "object", ".", "__doc__", "except", "AttributeError", ":", "return", "None", "if", "not", "isinstance", "(", "doc", ",", "types", ".", "StringTypes", ")", ":", "return", "None", "return", "cleandoc", "(", "doc", ")" ]

[ "Sends", "a", "HEAD", "request", ".", "Returns", ":", "class", ":", "Response", "object", "." ]

[ "def", "head", "(", "url", ",", "*", "*", "kwargs", ")", ":", "return", "request", "(", "'head'", ",", "url", ",", "*", "*", "kwargs", ")" ]

[]

[ "def", "close", "(", "self", ")", ":", "self", ".", "grpc_channel", ".", "close", "(", ")" ]

[ "Attempts", "to", "find", "a", "matching", "emote", "equaling", "the", "given", "word", "from", "the", "global", "emotes", "known", "to", "this", "manager", ".", "Returns", "None", "if", "no", "emote", "was", "matched" ]

[ "def", "match_global_emote", "(", "self", ",", "word", ":", "str", ")", "->", "Optional", "[", "Emote", "]", ":", "return", "self", ".", "global_lookup_table", ".", "get", "(", "word", ",", "None", ")" ]

[ "Real", "numbers", "have", "no", "imaginary", "component", "." ]

[ "def", "imag", "(", "self", ")", ":", "return", "0" ]

[ "Returns", "regression", "targets", "for", "each", "anchor", "." ]

[ "def", "_create_targets", "(", "anchors", ",", "groundtruth_boxes", ",", "matches", ")", ":", "matched_anchor_indices", "=", "tf", ".", "where", "(", "tf", ".", "greater_equal", "(", "matches", ",", "0", ")", ")", "# shape [num_matches, 1]", "matched_anchor_indices", "=", "tf", ".", "squeeze", "(", "matched_anchor_indices", ",", "axis", "=", "1", ")", "matched_gt_indices", "=", "tf", ".", "gather", "(", "matches", ",", "matched_anchor_indices", ")", "# shape [num_matches]", "matched_anchors", "=", "tf", ".", "gather", "(", "anchors", ",", "matched_anchor_indices", ")", "# shape [num_matches, 4]", "matched_gt_boxes", "=", "tf", ".", "gather", "(", "groundtruth_boxes", ",", "matched_gt_indices", ")", "# shape [num_matches, 4]", "matched_reg_targets", "=", "encode", "(", "matched_gt_boxes", ",", "matched_anchors", ")", "# shape [num_matches, 4]", "unmatched_anchor_indices", "=", "tf", ".", "where", "(", "tf", ".", "equal", "(", "matches", ",", "-", "1", ")", ")", "unmatched_anchor_indices", "=", "tf", ".", "squeeze", "(", "unmatched_anchor_indices", ",", "axis", "=", "1", ")", "# it has shape [num_anchors - num_matches]", "unmatched_reg_targets", "=", "tf", ".", "zeros", "(", "[", "tf", ".", "size", "(", "unmatched_anchor_indices", ")", ",", "4", "]", ")", "# it has shape [num_anchors - num_matches, 4]", "matched_anchor_indices", "=", "tf", ".", "to_int32", "(", "matched_anchor_indices", ")", "unmatched_anchor_indices", "=", "tf", ".", "to_int32", "(", "unmatched_anchor_indices", ")", "reg_targets", "=", "tf", ".", "dynamic_stitch", "(", "[", "matched_anchor_indices", ",", "unmatched_anchor_indices", "]", ",", "[", "matched_reg_targets", ",", "unmatched_reg_targets", "]", ")", "return", "reg_targets" ]

[]

[ "def", "poll", "(", "self", ")", ":", "return", "self", ".", "_internal_poll", "(", ")" ]

[ "给class图上色" ]

[ "def", "color_predicts", "(", "img", ")", ":", "# img = cv2.imread(label_path,cv2.CAP_MODE_GRAY)", "color", "=", "np", ".", "ones", "(", "[", "img", ".", "shape", "[", "0", "]", ",", "img", ".", "shape", "[", "1", "]", ",", "3", "]", ")", "color", "[", "img", "==", "0", "]", "=", "[", "255", ",", "255", ",", "255", "]", "#其他，白色，0", "color", "[", "img", "==", "1", "]", "=", "[", "0", ",", "255", ",", "0", "]", "#植被，绿色，1", "color", "[", "img", "==", "2", "]", "=", "[", "0", ",", "0", ",", "0", "]", "#道路，黑色，2", "color", "[", "img", "==", "3", "]", "=", "[", "131", ",", "139", ",", "139", "]", "#建筑，黄色，3", "color", "[", "img", "==", "4", "]", "=", "[", "139", ",", "69", ",", "19", "]", "#水体，蓝色，4", "return", "color" ]

[ "Polar", "to", "logpolar", "coordinates", "." ]

[ "def", "polar_to_logpolar", "(", "rho", ",", "theta", ")", ":", "# Shift in the SC mapping function in deg", "A", "=", "3.0", "# Collicular magnification along u axe in mm/rad", "Bx", "=", "1.4", "# Collicular magnification along v axe in mm/rad", "By", "=", "1.8", "xmin", ",", "xmax", "=", "0.0", ",", "4.80743279742", "ymin", ",", "ymax", "=", "-", "2.76745559565", ",", "2.76745559565", "rho", "=", "rho", "*", "90.0", "x", "=", "Bx", "*", "np", ".", "log", "(", "np", ".", "sqrt", "(", "rho", "*", "rho", "+", "2", "*", "A", "*", "rho", "*", "np", ".", "cos", "(", "theta", ")", "+", "A", "*", "A", ")", "/", "A", ")", "y", "=", "By", "*", "np", ".", "arctan", "(", "rho", "*", "np", ".", "sin", "(", "theta", ")", "/", "(", "rho", "*", "np", ".", "cos", "(", "theta", ")", "+", "A", ")", ")", "x", "=", "(", "x", "-", "xmin", ")", "/", "(", "xmax", "-", "xmin", ")", "y", "=", "(", "y", "-", "ymin", ")", "/", "(", "ymax", "-", "ymin", ")", "return", "x", ",", "y" ]

[ "Performs", "forward", "substitution", "given", "a", "lower", "triangular", "matrix", "a", "vector", "of", "variables", "and", "a", "vector", "of", "constants", "." ]

[ "def", "forward_substitution", "(", "lower_triangle", ",", "variable", ",", "constant", ",", "K", ")", ":", "copy_lower_triangle", "=", "copy", ".", "deepcopy", "(", "lower_triangle", ")", "nrow", "=", "len", "(", "copy_lower_triangle", ")", "for", "i", "in", "range", "(", "nrow", ")", ":", "a", "=", "K", ".", "zero", "for", "j", "in", "range", "(", "i", ")", ":", "a", "+=", "copy_lower_triangle", "[", "i", "]", "[", "j", "]", "*", "variable", "[", "j", "]", "[", "0", "]", "variable", "[", "i", "]", "[", "0", "]", "=", "(", "constant", "[", "i", "]", "[", "0", "]", "-", "a", ")", "/", "copy_lower_triangle", "[", "i", "]", "[", "i", "]", "return", "variable" ]

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

[ "def", "emit", "(", "self", ",", "record", ")", ":", "if", "self", ".", "_welu", ":", "try", ":", "id", "=", "self", ".", "getMessageID", "(", "record", ")", "cat", "=", "self", ".", "getEventCategory", "(", "record", ")", "type", "=", "self", ".", "getEventType", "(", "record", ")", "msg", "=", "self", ".", "format", "(", "record", ")", "self", ".", "_welu", ".", "ReportEvent", "(", "self", ".", "appname", ",", "id", ",", "cat", ",", "type", ",", "[", "msg", "]", ")", "except", "(", "KeyboardInterrupt", ",", "SystemExit", ")", ":", "raise", "except", ":", "self", ".", "handleError", "(", "record", ")" ]

[]

[ "def", "get_resource_stream", "(", "self", ",", "manager", ",", "resource_name", ")", ":", "return", "io", ".", "BytesIO", "(", "self", ".", "get_resource_string", "(", "manager", ",", "resource_name", ")", ")" ]

[]

[ "def", "checklookbehindgroup", "(", "self", ",", "gid", ",", "source", ")", ":", "if", "self", ".", "lookbehindgroups", "is", "not", "None", ":", "if", "not", "self", ".", "checkgroup", "(", "gid", ")", ":", "raise", "source", ".", "error", "(", "'cannot refer to an open group'", ")", "if", "gid", ">=", "self", ".", "lookbehindgroups", ":", "raise", "source", ".", "error", "(", "'cannot refer to group defined in the same '", "'lookbehind subpattern'", ")" ]

[ "清洗好友数据，生成csv", ":", "return", ":" ]

[ "def", "clean_friend_data", "(", "self", ")", ":", "try", ":", "if", "len", "(", "self", ".", "friend_list", ")", "==", "0", ":", "self", ".", "load_friend_data", "(", ")", "friend_total_num", "=", "len", "(", "self", ".", "friend_list", ")", "print", "(", "\"valid friend num:\"", ",", "friend_total_num", ")", "friend_list_df", "=", "pd", ".", "DataFrame", "(", "self", ".", "friend_list", ")", "self", ".", "friend_detail_list", "=", "[", "]", "if", "friend_total_num", "==", "0", ":", "print", "(", "\"该用户没有好友\")", "", "return", "False", "for", "friend", "in", "self", ".", "friend_detail", ":", "try", ":", "friend_uin", "=", "friend", "[", "'friendUin'", "]", "add_friend_time", "=", "friend", "[", "'addFriendTime'", "]", "img", "=", "friend_list_df", ".", "loc", "[", "friend_list_df", "[", "'uin'", "]", "==", "friend_uin", ",", "'img'", "]", ".", "values", "[", "0", "]", "nick", "=", "friend", "[", "'nick'", "]", "nick_name", "=", "remove_special_tag", "(", "nick", "[", "str", "(", "friend_uin", ")", "]", ")", "common_friend_num", "=", "len", "(", "friend", "[", "'common'", "]", "[", "'friend'", "]", ")", "common_group_num", "=", "len", "(", "friend", "[", "'common'", "]", "[", "'group'", "]", ")", "common_group_names", "=", "friend", "[", "'common'", "]", "[", "'group'", "]", "self", ".", "friend_detail_list", ".", "append", "(", "dict", "(", "uin", "=", "self", ".", "username", ",", "friend_uin", "=", "friend_uin", ",", "add_friend_time", "=", "add_friend_time", ",", "nick_name", "=", "nick_name", ",", "common_friend_num", "=", "common_friend_num", ",", "common_group_num", "=", "common_group_num", ",", "common_group_names", "=", "common_group_names", ",", "img", "=", "img", ")", ")", "except", "BaseException", "as", "e", ":", "if", "self", ".", "debug", ":", "print", "(", "\"单向好友:\", friend", ")", "", "", "self", ".", "friend_detail_list", ".", "append", "(", "dict", "(", "uin", "=", "0", ",", "friend_uin", "=", "friend", "[", "'friendUin'", "]", ",", "add_friend_time", "=", "0", ",", "nick_name", "=", "'单向好友', common", "_", "riend_num=0,", "", "", "", "common_group_num", "=", "0", ",", "common_group_names", "=", "''", ",", "img", "=", "''", ")", ")", "friend_df", "=", "pd", ".", "DataFrame", "(", "self", ".", "friend_detail_list", ")", "friend_df", ".", "sort_values", "(", "by", "=", "'add_friend_time'", ",", "inplace", "=", "True", ")", "friend_df", "[", "'add_friend_time2'", "]", "=", "friend_df", "[", "'add_friend_time'", "]", ".", "apply", "(", "lambda", "x", ":", "util", ".", "get_full_time_from_mktime", "(", "x", ")", ")", "friend_df", ".", "fillna", "(", "''", ",", "inplace", "=", "True", ")", "if", "self", ".", "export_excel", ":", "friend_df", ".", "to_excel", "(", "self", ".", "FRIEND_DETAIL_EXCEL_FILE_NAME", ")", "if", "self", ".", "export_csv", ":", "friend_df", ".", "to_csv", "(", "self", ".", "FRIEND_DETAIL_LIST_FILE_NAME", ")", "if", "self", ".", "debug", ":", "print", "(", "\"Finish to clean friend data...\"", ")", "print", "(", "\"File Name:\"", ",", "self", ".", "FRIEND_DETAIL_LIST_FILE_NAME", ")", "self", ".", "friend_df", "=", "friend_df", "return", "True", "except", "BaseException", "as", "e", ":", "self", ".", "format_error", "(", "e", ",", "\"Failed to parse friend_info\"", ")", "return", "False" ]

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

[ "def", "emit", "(", "self", ",", "record", ")", ":", "if", "self", ".", "_welu", ":", "try", ":", "id", "=", "self", ".", "getMessageID", "(", "record", ")", "cat", "=", "self", ".", "getEventCategory", "(", "record", ")", "type", "=", "self", ".", "getEventType", "(", "record", ")", "msg", "=", "self", ".", "format", "(", "record", ")", "self", ".", "_welu", ".", "ReportEvent", "(", "self", ".", "appname", ",", "id", ",", "cat", ",", "type", ",", "[", "msg", "]", ")", "except", "Exception", ":", "self", ".", "handleError", "(", "record", ")" ]

[]

[ "def", "get_return_code", "(", "self", ")", ":", "return", "self", ".", "process_wrapper", ".", "get_return_code", "(", ")" ]

[ "s", "-", ">", "(", "s0", "s1", ")", "(", "s1", "s2", ")", "(", "s2", "s3", ")", "..." ]

[ "def", "pairwise", "(", "iterable", ")", ":", "from", "itertools", "import", "tee", "a", ",", "b", "=", "tee", "(", "iterable", ")", "next", "(", "b", ",", "None", ")", "return", "zip", "(", "a", ",", "b", ")" ]

[ "This", "function", "is", "used", "to", "import", "or", "export", "based", "on", "the", "data" ]

[ "def", "save", "(", ")", ":", "required_args", "=", "[", "'type'", ",", "'filename'", "]", "data", "=", "request", ".", "form", "if", "request", ".", "form", "else", "json", ".", "loads", "(", "request", ".", "data", ".", "decode", "(", ")", ")", "for", "arg", "in", "required_args", ":", "if", "arg", "not", "in", "data", ":", "return", "make_json_response", "(", "status", "=", "410", ",", "success", "=", "0", ",", "errormsg", "=", "_", "(", "\"Could not find the required parameter ({}).\"", ")", ".", "format", "(", "arg", ")", ")", "status", "=", "False", "errmsg", "=", "None", "if", "data", "[", "'type'", "]", "==", "'export'", ":", "status", ",", "errmsg", "=", "dump_database_servers", "(", "data", "[", "'filename'", "]", ",", "data", "[", "'selected_sever_ids'", "]", ")", "elif", "data", "[", "'type'", "]", "==", "'import'", ":", "# Clear all the existing servers", "if", "'replace_servers'", "in", "data", "and", "data", "[", "'replace_servers'", "]", ":", "clear_database_servers", "(", ")", "status", ",", "errmsg", "=", "load_database_servers", "(", "data", "[", "'filename'", "]", ",", "data", "[", "'selected_sever_ids'", "]", ")", "if", "not", "status", ":", "return", "internal_server_error", "(", "errmsg", ")", "return", "make_json_response", "(", "success", "=", "1", ")" ]

[]

[ "def", "__str__", "(", "self", ")", ":", "s", "=", "\"%s = %s\"", "%", "(", "self", ".", "name", ",", "self", ".", "module_name", ")", "if", "self", ".", "attrs", ":", "s", "+=", "':'", "+", "'.'", ".", "join", "(", "self", ".", "attrs", ")", "if", "self", ".", "extras", ":", "s", "+=", "' [%s]'", "%", "','", ".", "join", "(", "self", ".", "extras", ")", "return", "s" ]

[ "return", "a", "single", "column", "from", "the", "table", ".", "This", "is", "generally", "only", "useful", "to", "select", "an", "indexable" ]

[ "def", "select_column", "(", "self", ",", "key", ",", "column", ",", "*", "*", "kwargs", ")", ":", "return", "self", ".", "get_storer", "(", "key", ")", ".", "read_column", "(", "column", "=", "column", ",", "*", "*", "kwargs", ")" ]

[ "Return", "a", "PokerTable", "object", "optimal", "table", "based", "on", "the", "given", "criteria", "in", "list_table_query_str", "plus", "the", "amount", "of", "currency", "the", "user", "represented", "by", "serial", "has", ".", "The", "caller", "is", "assured", "that", "the", "user", "represented", "by", "serial", "can", "afford", "at", "least", "the", "minimum", "buy", "-", "in", "for", "the", "table", "returned", "(", "if", "one", "is", "returned", ")", "." ]

[ "def", "getTableBestByCriteria", "(", "self", ",", "serial", ",", "currency_serial", "=", "None", ",", "variant", "=", "None", ",", "betting_structure", "=", "None", ",", "min_players", "=", "0", ")", ":", "bestTable", "=", "None", "# money_results dict is used to store lookups made to self.getMoney()", "money_results", "=", "{", "}", "# A bit of a cheat, listTables() caches the value for min_players", "# when it does parsing so that we can use it here.", "for", "rr", "in", "self", ".", "searchTables", "(", "currency_serial", ",", "variant", ",", "betting_structure", ",", "min_players", ")", ":", "table", "=", "self", ".", "getTable", "(", "rr", "[", "'serial'", "]", ")", "# Skip considering table entirely if it is full.", "if", "table", ".", "game", ".", "full", "(", ")", ":", "continue", "# Check to see that the players sitting out don't effecitvely", "# cause the user to fail to meet the number of players", "# criteria.", "if", "table", ".", "game", ".", "sitCount", "(", ")", "<", "min_players", ":", "continue", "buy_in", "=", "table", ".", "game", ".", "buyIn", "(", "serial", ")", "currency_serial", "=", "rr", "[", "'currency_serial'", "]", "if", "not", "money_results", ".", "has_key", "(", "currency_serial", ")", ":", "money_results", "[", "currency_serial", "]", "=", "self", ".", "getMoney", "(", "serial", ",", "currency_serial", ")", "if", "money_results", "[", "currency_serial", "]", ">", "buy_in", ":", "# If the user can afford the buy_in, we've found a table for them!", "bestTable", "=", "table", "break", "return", "bestTable" ]

[ "This", "method", "factors", "out", "what", "is", "essentially", "grid", "printing", "." ]

[ "def", "_print_matrix_contents", "(", "self", ",", "e", ")", ":", "M", "=", "e", "# matrix", "Ms", "=", "{", "}", "# i,j -> pretty(M[i,j])", "for", "i", "in", "range", "(", "M", ".", "rows", ")", ":", "for", "j", "in", "range", "(", "M", ".", "cols", ")", ":", "Ms", "[", "i", ",", "j", "]", "=", "self", ".", "_print", "(", "M", "[", "i", ",", "j", "]", ")", "# h- and v- spacers", "hsep", "=", "2", "vsep", "=", "1", "# max width for columns", "maxw", "=", "[", "-", "1", "]", "*", "M", ".", "cols", "for", "j", "in", "range", "(", "M", ".", "cols", ")", ":", "maxw", "[", "j", "]", "=", "max", "(", "[", "Ms", "[", "i", ",", "j", "]", ".", "width", "(", ")", "for", "i", "in", "range", "(", "M", ".", "rows", ")", "]", "or", "[", "0", "]", ")", "# drawing result", "D", "=", "None", "for", "i", "in", "range", "(", "M", ".", "rows", ")", ":", "D_row", "=", "None", "for", "j", "in", "range", "(", "M", ".", "cols", ")", ":", "s", "=", "Ms", "[", "i", ",", "j", "]", "# reshape s to maxw", "# XXX this should be generalized, and go to stringPict.reshape ?", "assert", "s", ".", "width", "(", ")", "<=", "maxw", "[", "j", "]", "# hcenter it, +0.5 to the right 2", "# ( it's better to align formula starts for say 0 and r )", "# XXX this is not good in all cases -- maybe introduce vbaseline?", "wdelta", "=", "maxw", "[", "j", "]", "-", "s", ".", "width", "(", ")", "wleft", "=", "wdelta", "//", "2", "wright", "=", "wdelta", "-", "wleft", "s", "=", "prettyForm", "(", "*", "s", ".", "right", "(", "' '", "*", "wright", ")", ")", "s", "=", "prettyForm", "(", "*", "s", ".", "left", "(", "' '", "*", "wleft", ")", ")", "# we don't need vcenter cells -- this is automatically done in", "# a pretty way because when their baselines are taking into", "# account in .right()", "if", "D_row", "is", "None", ":", "D_row", "=", "s", "# first box in a row", "continue", "D_row", "=", "prettyForm", "(", "*", "D_row", ".", "right", "(", "' '", "*", "hsep", ")", ")", "# h-spacer", "D_row", "=", "prettyForm", "(", "*", "D_row", ".", "right", "(", "s", ")", ")", "if", "D", "is", "None", ":", "D", "=", "D_row", "# first row in a picture", "continue", "# v-spacer", "for", "_", "in", "range", "(", "vsep", ")", ":", "D", "=", "prettyForm", "(", "*", "D", ".", "below", "(", "' '", ")", ")", "D", "=", "prettyForm", "(", "*", "D", ".", "below", "(", "D_row", ")", ")", "if", "D", "is", "None", ":", "D", "=", "prettyForm", "(", "''", ")", "# Empty Matrix", "return", "D" ]

[]

[ "def", "initialize", "(", "interp", ":", "'Interpreter'", ")", "->", "WindowsModule", ":", "return", "WindowsModule", "(", "interp", ")" ]

[ "Create", "the", "generator", "for", "message", "flattening", "." ]

[ "def", "__init__", "(", "self", ",", "outfp", ",", "mangle_from_", "=", "None", ",", "maxheaderlen", "=", "None", ",", "*", ",", "policy", "=", "None", ")", ":", "if", "mangle_from_", "is", "None", ":", "mangle_from_", "=", "True", "if", "policy", "is", "None", "else", "policy", ".", "mangle_from_", "self", ".", "_fp", "=", "outfp", "self", ".", "_mangle_from_", "=", "mangle_from_", "self", ".", "maxheaderlen", "=", "maxheaderlen", "self", ".", "policy", "=", "policy" ]

[ "Enable", "encryption", "with", "the", "specified", "keys", "." ]

[ "def", "enable_encryption", "(", "self", ",", "output_key", ":", "bytes", ",", "input_key", ":", "bytes", ")", "->", "None", ":", "self", ".", "chacha", "=", "chacha20", ".", "Chacha20Cipher", "(", "output_key", ",", "input_key", ",", "nonce_length", "=", "12", ")" ]

[ "Sets", "attribute", "with", "name", "i", "or", "component", "#i", "." ]

[ "def", "__setitem__", "(", "self", ",", "i", ",", "value", ")", ":", "self", ".", "_setnode", "(", "value", ")", "if", "isinstance", "(", "i", ",", "(", "str", ",", "unicode", ")", ")", ":", "self", ".", "attributes", "[", "i", "]", "=", "value", "else", ":", "self", ".", "components", "[", "i", "]", "=", "value" ]

[ "Parse", "mac", "application", "bundle", "and", "return", "path", "for", "*", ".", "icns", "file", "." ]

[ "def", "_get_mac_application_icon_path", "(", "app_bundle_path", ")", ":", "import", "plistlib", "contents_path", "=", "info_path", "=", "os", ".", "path", ".", "join", "(", "app_bundle_path", ",", "'Contents'", ")", "info_path", "=", "os", ".", "path", ".", "join", "(", "contents_path", ",", "'Info.plist'", ")", "pl", "=", "{", "}", "if", "os", ".", "path", ".", "isfile", "(", "info_path", ")", ":", "try", ":", "# readPlist is deprecated but needed for py27 compat", "pl", "=", "plistlib", ".", "readPlist", "(", "info_path", ")", "except", "Exception", ":", "pass", "icon_file", "=", "pl", ".", "get", "(", "'CFBundleIconFile'", ")", "icon_path", "=", "None", "if", "icon_file", ":", "icon_path", "=", "os", ".", "path", ".", "join", "(", "contents_path", ",", "'Resources'", ",", "icon_file", ")", "# Some app bundles seem to list the icon name without extension", "if", "not", "icon_path", ".", "endswith", "(", "'.icns'", ")", ":", "icon_path", "=", "icon_path", "+", "'.icns'", "if", "not", "os", ".", "path", ".", "isfile", "(", "icon_path", ")", ":", "icon_path", "=", "None", "return", "icon_path" ]

[ "Shortcuts", "is", "a", "dict", "of", ":", "accelerator", "string", ":", "(", "self", ".", "_function", "[", "arguments", "]", ")" ]

[ "def", "process_shortcuts", "(", "shortcuts", ",", "event", ":", "Gdk", ".", "Event", ")", ":", "if", "event", ".", "type", "!=", "Gdk", ".", "EventType", ".", "KEY_PRESS", ":", "return", "for", "accel_string", ",", "value", "in", "shortcuts", ".", "items", "(", ")", ":", "key", ",", "mods", "=", "Gtk", ".", "accelerator_parse", "(", "accel_string", ")", "emods", "=", "event", ".", "state", "&", "(", "Gdk", ".", "ModifierType", ".", "CONTROL_MASK", "|", "Gdk", ".", "ModifierType", ".", "SHIFT_MASK", ")", "if", "event", ".", "keyval", "==", "key", "and", "(", "emods", "&", "mods", "or", "mods", "==", "emods", "==", "0", ")", ":", "func", ",", "args", "=", "value", "try", ":", "func", "(", "*", "args", ")", "except", "Exception", "as", "e", ":", "raise", "return", "False", "return", "True" ]

[ "Obtain", "token", "by", "a", "device", "flow", "object", "with", "customizable", "polling", "effect", "." ]

[ "def", "obtain_token_by_device_flow", "(", "self", ",", "flow", ",", "exit_condition", "=", "lambda", "flow", ":", "flow", ".", "get", "(", "\"expires_at\"", ",", "0", ")", "<", "time", ".", "time", "(", ")", ",", "*", "*", "kwargs", ")", ":", "# type: (dict, Callable) -> dict", "while", "True", ":", "result", "=", "self", ".", "_obtain_token_by_device_flow", "(", "flow", ",", "*", "*", "kwargs", ")", "if", "result", ".", "get", "(", "\"error\"", ")", "not", "in", "self", ".", "DEVICE_FLOW_RETRIABLE_ERRORS", ":", "return", "result", "for", "i", "in", "range", "(", "flow", ".", "get", "(", "\"interval\"", ",", "5", ")", ")", ":", "# Wait interval seconds", "if", "exit_condition", "(", "flow", ")", ":", "return", "result", "time", ".", "sleep", "(", "1", ")" ]

[]

[ "def", "find_by_name", "(", "self", ",", "name", ":", "str", ")", "->", "Optional", "[", "Node", "]", ":", "for", "node", "in", "self", ".", "graph", ".", "nodes", ":", "if", "node", ".", "name", "==", "name", ":", "return", "node", "return", "None" ]

[ "Count", "the", "number", "of", "lines", "in", "a", "given", "string", "." ]

[ "def", "count_lines_with_wrapping", "(", "s", ",", "linewidth", "=", "80", ")", ":", "tabwidth", "=", "8", "# Currently always true in Shell.", "pos", "=", "0", "linecount", "=", "1", "current_column", "=", "0", "for", "m", "in", "re", ".", "finditer", "(", "r\"[\\t\\n]\"", ",", "s", ")", ":", "# Process the normal chars up to tab or newline.", "numchars", "=", "m", ".", "start", "(", ")", "-", "pos", "pos", "+=", "numchars", "current_column", "+=", "numchars", "# Deal with tab or newline.", "if", "s", "[", "pos", "]", "==", "'\\n'", ":", "# Avoid the `current_column == 0` edge-case, and while we're", "# at it, don't bother adding 0.", "if", "current_column", ">", "linewidth", ":", "# If the current column was exactly linewidth, divmod", "# would give (1,0), even though a new line hadn't yet", "# been started. The same is true if length is any exact", "# multiple of linewidth. Therefore, subtract 1 before", "# dividing a non-empty line.", "linecount", "+=", "(", "current_column", "-", "1", ")", "//", "linewidth", "linecount", "+=", "1", "current_column", "=", "0", "else", ":", "assert", "s", "[", "pos", "]", "==", "'\\t'", "current_column", "+=", "tabwidth", "-", "(", "current_column", "%", "tabwidth", ")", "# If a tab passes the end of the line, consider the entire", "# tab as being on the next line.", "if", "current_column", ">", "linewidth", ":", "linecount", "+=", "1", "current_column", "=", "tabwidth", "pos", "+=", "1", "# After the tab or newline.", "# Process remaining chars (no more tabs or newlines).", "current_column", "+=", "len", "(", "s", ")", "-", "pos", "# Avoid divmod(-1, linewidth).", "if", "current_column", ">", "0", ":", "linecount", "+=", "(", "current_column", "-", "1", ")", "//", "linewidth", "else", ":", "# Text ended with newline; don't count an extra line after it.", "linecount", "-=", "1", "return", "linecount" ]

[ "Tokenizes", "a", "piece", "of", "text", "." ]

[ "def", "tokenize", "(", "self", ",", "text", ")", ":", "text", "=", "convert_to_unicode", "(", "text", ")", "text", "=", "self", ".", "_clean_text", "(", "text", ")", "# This was added on November 1st, 2018 for the multilingual and Chinese", "# models. This is also applied to the English models now, but it doesn't", "# matter since the English models were not trained on any Chinese data", "# and generally don't have any Chinese data in them (there are Chinese", "# characters in the vocabulary because Wikipedia does have some Chinese", "# words in the English Wikipedia.).", "text", "=", "self", ".", "_tokenize_chinese_chars", "(", "text", ")", "orig_tokens", "=", "whitespace_tokenize", "(", "text", ")", "split_tokens", "=", "[", "]", "for", "token", "in", "orig_tokens", ":", "if", "self", ".", "do_lower_case", ":", "token", "=", "token", ".", "lower", "(", ")", "token", "=", "self", ".", "_run_strip_accents", "(", "token", ")", "split_tokens", ".", "extend", "(", "self", ".", "_run_split_on_punc", "(", "token", ")", ")", "output_tokens", "=", "whitespace_tokenize", "(", "\" \"", ".", "join", "(", "split_tokens", ")", ")", "return", "output_tokens" ]

[]

[ "def", "forward", "(", "self", ",", "hidden_states", ",", "input_tensor", ")", ":", "hidden_states", "=", "self", ".", "dense", "(", "hidden_states", ")", "hidden_states", "=", "self", ".", "dropout", "(", "hidden_states", ")", "hidden_states", "=", "self", ".", "LayerNorm", "(", "hidden_states", "+", "input_tensor", ")", "return", "hidden_states" ]

[]

[ "def", "_parse", "(", "self", ",", "file", ",", "fp", ",", "default_netrc", ")", ":", "lexer", "=", "shlex", ".", "shlex", "(", "fp", ")", "lexer", ".", "wordchars", "+=", "r\"\"\"!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~\"\"\"", "lexer", ".", "commenters", "=", "lexer", ".", "commenters", ".", "replace", "(", "'#'", ",", "''", ")", "while", "1", ":", "# Look for a machine, default, or macdef top-level keyword", "saved_lineno", "=", "lexer", ".", "lineno", "toplevel", "=", "tt", "=", "lexer", ".", "get_token", "(", ")", "if", "not", "tt", ":", "break", "elif", "tt", "[", "0", "]", "==", "'#'", ":", "if", "lexer", ".", "lineno", "==", "saved_lineno", "and", "len", "(", "tt", ")", "==", "1", ":", "lexer", ".", "instream", ".", "readline", "(", ")", "continue", "elif", "tt", "==", "'machine'", ":", "entryname", "=", "lexer", ".", "get_token", "(", ")", "elif", "tt", "==", "'default'", ":", "entryname", "=", "'default'", "elif", "tt", "==", "'macdef'", ":", "# Just skip to end of macdefs", "entryname", "=", "lexer", ".", "get_token", "(", ")", "self", ".", "macros", "[", "entryname", "]", "=", "[", "]", "lexer", ".", "whitespace", "=", "' \\t'", "while", "1", ":", "line", "=", "lexer", ".", "instream", ".", "readline", "(", ")", "if", "not", "line", "or", "line", "==", "'\\012'", ":", "lexer", ".", "whitespace", "=", "' \\t\\r\\n'", "break", "self", ".", "macros", "[", "entryname", "]", ".", "append", "(", "line", ")", "continue", "else", ":", "raise", "NetrcParseError", "(", "\"bad toplevel token %r\"", "%", "tt", ",", "file", ",", "lexer", ".", "lineno", ")", "# We're looking at start of an entry for a named machine or default.", "login", "=", "''", "account", "=", "password", "=", "None", "self", ".", "hosts", "[", "entryname", "]", "=", "{", "}", "while", "1", ":", "tt", "=", "lexer", ".", "get_token", "(", ")", "if", "(", "tt", ".", "startswith", "(", "'#'", ")", "or", "tt", "in", "{", "''", ",", "'machine'", ",", "'default'", ",", "'macdef'", "}", ")", ":", "if", "password", ":", "self", ".", "hosts", "[", "entryname", "]", "=", "(", "login", ",", "account", ",", "password", ")", "lexer", ".", "push_token", "(", "tt", ")", "break", "else", ":", "raise", "NetrcParseError", "(", "\"malformed %s entry %s terminated by %s\"", "%", "(", "toplevel", ",", "entryname", ",", "repr", "(", "tt", ")", ")", ",", "file", ",", "lexer", ".", "lineno", ")", "elif", "tt", "==", "'login'", "or", "tt", "==", "'user'", ":", "login", "=", "lexer", ".", "get_token", "(", ")", "elif", "tt", "==", "'account'", ":", "account", "=", "lexer", ".", "get_token", "(", ")", "elif", "tt", "==", "'password'", ":", "if", "os", ".", "name", "==", "'posix'", "and", "default_netrc", ":", "prop", "=", "os", ".", "fstat", "(", "fp", ".", "fileno", "(", ")", ")", "if", "prop", ".", "st_uid", "!=", "os", ".", "getuid", "(", ")", ":", "import", "pwd", "try", ":", "fowner", "=", "pwd", ".", "getpwuid", "(", "prop", ".", "st_uid", ")", "[", "0", "]", "except", "KeyError", ":", "fowner", "=", "'uid %s'", "%", "prop", ".", "st_uid", "try", ":", "user", "=", "pwd", ".", "getpwuid", "(", "os", ".", "getuid", "(", ")", ")", "[", "0", "]", "except", "KeyError", ":", "user", "=", "'uid %s'", "%", "os", ".", "getuid", "(", ")", "raise", "NetrcParseError", "(", "(", "\"~/.netrc file owner (%s) does not match\"", "\" current user (%s)\"", ")", "%", "(", "fowner", ",", "user", ")", ",", "file", ",", "lexer", ".", "lineno", ")", "if", "(", "prop", ".", "st_mode", "&", "(", "stat", ".", "S_IRWXG", "|", "stat", ".", "S_IRWXO", ")", ")", ":", "raise", "NetrcParseError", "(", "\"~/.netrc access too permissive: access\"", "\" permissions must restrict access to only\"", "\" the owner\"", ",", "file", ",", "lexer", ".", "lineno", ")", "password", "=", "lexer", ".", "get_token", "(", ")", "else", ":", "raise", "NetrcParseError", "(", "\"bad follower token %r\"", "%", "tt", ",", "file", ",", "lexer", ".", "lineno", ")" ]

[ "Unwraps", "an", "image", "produced", "by", "wrap", "." ]

[ "def", "unwrap", "(", "image", ",", "replace", ")", ":", "image_shape", "=", "image", ".", "shape", "# Flatten the spatial dimensions.", "flattened_image", "=", "np", ".", "reshape", "(", "image", ",", "[", "-", "1", ",", "image_shape", "[", "2", "]", "]", ")", "# Find all pixels where the last channel is zero.", "alpha_channel", "=", "flattened_image", "[", ":", ",", "3", "]", "replace", "=", "np", ".", "concatenate", "(", "[", "replace", ",", "np", ".", "ones", "(", "[", "1", "]", ",", "image", ".", "dtype", ")", "]", ",", "0", ")", "# Where they are zero, fill them in with 'replace'.", "alpha_channel", "=", "np", ".", "reshape", "(", "alpha_channel", ",", "(", "-", "1", ",", "1", ")", ")", "alpha_channel", "=", "np", ".", "tile", "(", "alpha_channel", ",", "reps", "=", "(", "1", ",", "flattened_image", ".", "shape", "[", "1", "]", ")", ")", "flattened_image", "=", "np", ".", "where", "(", "np", ".", "equal", "(", "alpha_channel", ",", "0", ")", ",", "np", ".", "ones_like", "(", "flattened_image", ",", "dtype", "=", "image", ".", "dtype", ")", "*", "replace", ",", "flattened_image", ")", "image", "=", "np", ".", "reshape", "(", "flattened_image", ",", "image_shape", ")", "image", "=", "image", "[", ":", ",", ":", ",", ":", "3", "]", "return", "image", ".", "astype", "(", "np", ".", "uint8", ")" ]

[ "Add", "intersections", "of", "the", "loops", "with", "the", "x", "segment", "." ]

[ "def", "addLoopsXSegmentIntersections", "(", "lineLoopsIntersections", ",", "loops", ",", "segmentFirstX", ",", "segmentSecondX", ",", "segmentYMirror", ",", "y", ")", ":", "for", "loop", "in", "loops", ":", "addLoopXSegmentIntersections", "(", "lineLoopsIntersections", ",", "loop", ",", "segmentFirstX", ",", "segmentSecondX", ",", "segmentYMirror", ",", "y", ")" ]

[]

[ "def", "skeleton_preprocess", "(", "image", ",", "bboxes", ",", "skeleton_cfg", ")", ":", "# output collector", "result_list", "=", "[", "]", "meta", "=", "dict", "(", ")", "meta", "[", "'scale'", "]", "=", "[", "]", "meta", "[", "'rotation'", "]", "=", "[", "]", "meta", "[", "'center'", "]", "=", "[", "]", "meta", "[", "'score'", "]", "=", "[", "]", "# preprocess config", "image_size", "=", "skeleton_cfg", ".", "image_size", "image_width", "=", "image_size", "[", "0", "]", "image_height", "=", "image_size", "[", "1", "]", "aspect_ratio", "=", "image_width", "*", "1.0", "/", "image_height", "pixel_std", "=", "skeleton_cfg", ".", "pixel_std", "image_mean", "=", "skeleton_cfg", ".", "image_mean", "image_std", "=", "skeleton_cfg", ".", "image_std", "for", "idx", ",", "bbox", "in", "enumerate", "(", "bboxes", ")", ":", "x1", ",", "y1", ",", "x2", ",", "y2", "=", "bbox", "[", ":", "4", "]", "w", ",", "h", "=", "x2", "-", "x1", ",", "y2", "-", "y1", "center", ",", "scale", "=", "xywh2cs", "(", "x1", ",", "y1", ",", "h", ",", "w", ",", "aspect_ratio", ",", "pixel_std", ")", "trans", "=", "get_affine_transform", "(", "center", ",", "scale", ",", "0", ",", "image_size", ")", "transformed_image", "=", "cv2", ".", "warpAffine", "(", "image", ",", "trans", ",", "(", "int", "(", "image_size", "[", "0", "]", ")", ",", "int", "(", "image_size", "[", "1", "]", ")", ")", ",", "flags", "=", "cv2", ".", "INTER_LINEAR", ")", "# transfer into Torch.Tensor", "transformed_image", "=", "transformed_image", "/", "255.0", "transformed_image", "=", "transformed_image", "-", "image_mean", "transformed_image", "=", "transformed_image", "/", "image_std", "transformed_image", "=", "transformed_image", ".", "transpose", "(", "2", ",", "0", ",", "1", ")", "result_list", ".", "append", "(", "transformed_image", ")", "# from IPython import embed; embed()", "meta", "[", "'scale'", "]", ".", "append", "(", "scale", ")", "meta", "[", "'rotation'", "]", ".", "append", "(", "0", ")", "meta", "[", "'center'", "]", ".", "append", "(", "center", ")", "meta", "[", "'score'", "]", ".", "append", "(", "bbox", "[", "4", "]", ")", "result", "=", "torch", ".", "from_numpy", "(", "np", ".", "array", "(", "result_list", ")", ")", ".", "float", "(", ")", "for", "name", ",", "data", "in", "meta", ".", "items", "(", ")", ":", "meta", "[", "name", "]", "=", "torch", ".", "from_numpy", "(", "np", ".", "array", "(", "data", ")", ")", ".", "float", "(", ")", "return", "result", ",", "meta" ]

[ "Add", "documentation", "to", "a", "function", "." ]

[ "def", "_add_doc", "(", "func", ",", "doc", ")", ":", "func", ".", "__doc__", "=", "doc" ]

[ "initialize", "the", "factorization", "weight", "vector", "for", "variable", "i", "." ]

[ "def", "init_fm", "(", "self", ",", "i", ")", ":", "if", "i", "not", "in", "self", ".", "n_fm", ":", "self", ".", "n_fm", "[", "i", "]", "=", "[", "0.", "]", "*", "self", ".", "fm_dim", "self", ".", "w_fm", "[", "i", "]", "=", "[", "0.", "]", "*", "self", ".", "fm_dim", "self", ".", "z_fm", "[", "i", "]", "=", "[", "0.", "]", "*", "self", ".", "fm_dim", "for", "k", "in", "range", "(", "self", ".", "fm_dim", ")", ":", "self", ".", "z_fm", "[", "i", "]", "[", "k", "]", "=", "random", ".", "gauss", "(", "0.", ",", "self", ".", "fm_initDev", ")" ]

[ "Format", "a", "section", "with", "a", "heading", "." ]

[ "def", "section", "(", "self", ",", "title", ",", "fgcol", ",", "bgcol", ",", "contents", ",", "width", "=", "6", ",", "prelude", "=", "''", ",", "marginalia", "=", "None", ",", "gap", "=", "'&nbsp;'", ")", ":", "if", "marginalia", "is", "None", ":", "marginalia", "=", "'<tt>'", "+", "'&nbsp;'", "*", "width", "+", "'</tt>'", "result", "=", "'''<p>\n<table width=\"100%%\" cellspacing=0 cellpadding=2 border=0 summary=\"section\">\n<tr bgcolor=\"%s\">\n<td colspan=3 valign=bottom>&nbsp;<br>\n<font color=\"%s\" face=\"helvetica, arial\">%s</font></td></tr>\n '''", "%", "(", "bgcol", ",", "fgcol", ",", "title", ")", "if", "prelude", ":", "result", "=", "result", "+", "'''\n<tr bgcolor=\"%s\"><td rowspan=2>%s</td>\n<td colspan=2>%s</td></tr>\n<tr><td>%s</td>'''", "%", "(", "bgcol", ",", "marginalia", ",", "prelude", ",", "gap", ")", "else", ":", "result", "=", "result", "+", "'''\n<tr><td bgcolor=\"%s\">%s</td><td>%s</td>'''", "%", "(", "bgcol", ",", "marginalia", ",", "gap", ")", "return", "result", "+", "'\\n<td width=\"100%%\">%s</td></tr></table>'", "%", "contents" ]

[ "Expand", "the", "flex", "-", "flow", "property", "." ]

[ "def", "expand_flex_flow", "(", "name", ",", "tokens", ")", ":", "if", "len", "(", "tokens", ")", "==", "2", ":", "for", "sorted_tokens", "in", "tokens", ",", "tokens", "[", ":", ":", "-", "1", "]", ":", "direction", "=", "flex_direction", "(", "[", "sorted_tokens", "[", "0", "]", "]", ")", "wrap", "=", "flex_wrap", "(", "[", "sorted_tokens", "[", "1", "]", "]", ")", "if", "direction", "and", "wrap", ":", "yield", "'flex-direction'", ",", "[", "sorted_tokens", "[", "0", "]", "]", "yield", "'flex-wrap'", ",", "[", "sorted_tokens", "[", "1", "]", "]", "break", "else", ":", "raise", "InvalidValues", "elif", "len", "(", "tokens", ")", "==", "1", ":", "direction", "=", "flex_direction", "(", "[", "tokens", "[", "0", "]", "]", ")", "if", "direction", ":", "yield", "'flex-direction'", ",", "[", "tokens", "[", "0", "]", "]", "else", ":", "wrap", "=", "flex_wrap", "(", "[", "tokens", "[", "0", "]", "]", ")", "if", "wrap", ":", "yield", "'flex-wrap'", ",", "[", "tokens", "[", "0", "]", "]", "else", ":", "raise", "InvalidValues", "else", ":", "raise", "InvalidValues" ]

[ "Writes", "out", "and", "forgets", "all", "headers", "accumulated", "so", "far", "." ]

[ "def", "flushheaders", "(", "self", ")", ":", "self", ".", "_fp", ".", "writelines", "(", "self", ".", "_headers", ")", "self", ".", "_headers", "=", "[", "]" ]

[ "Indicate", "that", "the", "given", "attribute", "should", "be", "loaded", "using", "subquery", "eager", "loading", "." ]

[ "def", "subqueryload", "(", "loadopt", ",", "attr", ")", ":", "return", "loadopt", ".", "set_relationship_strategy", "(", "attr", ",", "{", "\"lazy\"", ":", "\"subquery\"", "}", ")" ]

[ "Log", "an", "info", "message", "." ]

[ "def", "log_info", "(", "self", ",", "message", ",", "logger", "=", "'_logger'", ")", ":", "self", ".", "_log_message", "(", "'INFO'", ",", "message", ",", "logger", ")" ]

[]

[ "def", "update", "(", "self", ",", "data", ")", ":", "self", ".", "_h", ".", "update", "(", "data", ")" ]

[ "Return", "the", "ceiling", "of", "self", "as", "an", "integer", "." ]

[ "def", "__ceil__", "(", "self", ")", ":", "if", "self", ".", "_is_special", ":", "if", "self", ".", "is_nan", "(", ")", ":", "raise", "ValueError", "(", "\"cannot round a NaN\"", ")", "else", ":", "raise", "OverflowError", "(", "\"cannot round an infinity\"", ")", "return", "int", "(", "self", ".", "_rescale", "(", "0", ",", "ROUND_CEILING", ")", ")" ]

[]

[ "def", "itemsNS", "(", "self", ")", ":", "L", "=", "[", "]", "for", "node", "in", "self", ".", "_attrs", ".", "values", "(", ")", ":", "L", ".", "append", "(", "(", "(", "node", ".", "namespaceURI", ",", "node", ".", "localName", ")", ",", "node", ".", "value", ")", ")", "return", "L" ]

[ "Stop", "the", "cover", "." ]

[ "def", "stop_cover", "(", "self", ",", "*", "*", "kwargs", ")", ":", "self", ".", "_blind", ".", "Stop", "(", "motor", "=", "self", ".", "_motor_key", ")" ]

[ "Removes", "logrotate", "script", "for", "the", "given", "project", "." ]

[ "def", "remove_logrotate", "(", "project_id", ")", ":", "app_logrotate_script", "=", "\"{0}/appscale-{1}\"", ".", "format", "(", "LOGROTATE_CONFIG_DIR", ",", "project_id", ")", "logger", ".", "debug", "(", "\"Removing script: {}\"", ".", "format", "(", "app_logrotate_script", ")", ")", "try", ":", "os", ".", "remove", "(", "app_logrotate_script", ")", "except", "OSError", ":", "logging", ".", "error", "(", "\"Error while removing log rotation for application: {}\"", ".", "format", "(", "project_id", ")", ")" ]

[]

[ "def", "IN_CLASSB", "(", "i", ")", ":", "return", "(", "(", "(", "__int32_t", ")", "(", "i", ")", "&", "0xc0000000", ")", "==", "0x80000000", ")" ]

[ "Channel", "shuffle", "layer", ".", "This", "is", "a", "wrapper", "over", "the", "same", "operation", ".", "It", "is", "designed", "to", "save", "the", "number", "of", "groups", "." ]

[ "def", "channel_shuffle_lambda", "(", "channels", ",", "groups", ",", "*", "*", "kwargs", ")", ":", "assert", "(", "channels", "%", "groups", "==", "0", ")", "return", "nn", ".", "Lambda", "(", "channel_shuffle", ",", "arguments", "=", "{", "\"groups\"", ":", "groups", "}", ",", "*", "*", "kwargs", ")" ]

[ "Calculate", "particle", "vector", "at", "launch", "." ]

[ "def", "vector", "(", "self", ")", ":", "angles", "=", "[", "65", ",", "55", ",", "45", ",", "35", ",", "25", "]", "# 90 is vertical", "orient", "=", "random", ".", "choice", "(", "angles", ")", "if", "orient", "==", "45", ":", "self", ".", "color", "=", "WHITE", "else", ":", "self", ".", "color", "=", "GRAY", "radians", "=", "math", ".", "radians", "(", "orient", ")", "self", ".", "dx", "=", "self", ".", "vel", "*", "math", ".", "cos", "(", "radians", ")", "self", ".", "dy", "=", "-", "self", ".", "vel", "*", "math", ".", "sin", "(", "radians", ")" ]

[ "Set", "widgets", "on", "the", "Threshold", "tab", "." ]

[ "def", "set_widgets", "(", "self", ")", ":", "clear_layout", "(", "self", ".", "gridLayoutThreshold", ")", "# Set text in the label", "layer_purpose", "=", "self", ".", "parent", ".", "step_kw_purpose", ".", "selected_purpose", "(", ")", "layer_subcategory", "=", "self", ".", "parent", ".", "step_kw_subcategory", ".", "selected_subcategory", "(", ")", "classification", "=", "self", ".", "parent", ".", "step_kw_classification", ".", "selected_classification", "(", ")", "if", "is_raster_layer", "(", "self", ".", "parent", ".", "layer", ")", ":", "statistics", "=", "self", ".", "parent", ".", "layer", ".", "dataProvider", "(", ")", ".", "bandStatistics", "(", "1", ",", "QgsRasterBandStats", ".", "All", ",", "self", ".", "parent", ".", "layer", ".", "extent", "(", ")", ",", "0", ")", "text", "=", "continuous_raster_question", "%", "(", "layer_purpose", "[", "'name'", "]", ",", "layer_subcategory", "[", "'name'", "]", ",", "classification", "[", "'name'", "]", ",", "statistics", ".", "minimumValue", ",", "statistics", ".", "maximumValue", ")", "else", ":", "field_name", "=", "self", ".", "parent", ".", "step_kw_field", ".", "selected_fields", "(", ")", "field_index", "=", "self", ".", "parent", ".", "layer", ".", "fields", "(", ")", ".", "lookupField", "(", "field_name", ")", "min_value_layer", "=", "self", ".", "parent", ".", "layer", ".", "minimumValue", "(", "field_index", ")", "max_value_layer", "=", "self", ".", "parent", ".", "layer", ".", "maximumValue", "(", "field_index", ")", "text", "=", "continuous_vector_question", "%", "(", "layer_purpose", "[", "'name'", "]", ",", "layer_subcategory", "[", "'name'", "]", ",", "field_name", ",", "classification", "[", "'name'", "]", ",", "min_value_layer", ",", "max_value_layer", ")", "self", ".", "lblThreshold", ".", "setText", "(", "text", ")", "thresholds", "=", "self", ".", "parent", ".", "get_existing_keyword", "(", "'thresholds'", ")", "selected_unit", "=", "self", ".", "parent", ".", "step_kw_unit", ".", "selected_unit", "(", ")", "[", "'key'", "]", "self", ".", "classes", "=", "OrderedDict", "(", ")", "classes", "=", "classification", ".", "get", "(", "'classes'", ")", "# Sort by value, put the lowest first", "classes", "=", "sorted", "(", "classes", ",", "key", "=", "lambda", "k", ":", "k", "[", "'value'", "]", ")", "for", "i", ",", "the_class", "in", "enumerate", "(", "classes", ")", ":", "class_layout", "=", "QHBoxLayout", "(", ")", "# Class label", "class_label", "=", "QLabel", "(", "the_class", "[", "'name'", "]", ")", "# Min label", "min_label", "=", "QLabel", "(", "tr", "(", "'Min >'", ")", ")", "# Min value as double spin", "min_value_input", "=", "QDoubleSpinBox", "(", ")", "# TODO(IS) We can set the min and max depends on the unit, later", "min_value_input", ".", "setMinimum", "(", "0", ")", "min_value_input", ".", "setMaximum", "(", "999999", ")", "if", "thresholds", ".", "get", "(", "the_class", "[", "'key'", "]", ")", ":", "min_value_input", ".", "setValue", "(", "thresholds", "[", "the_class", "[", "'key'", "]", "]", "[", "0", "]", ")", "else", ":", "default_min", "=", "the_class", "[", "'numeric_default_min'", "]", "if", "isinstance", "(", "default_min", ",", "dict", ")", ":", "default_min", "=", "the_class", "[", "'numeric_default_min'", "]", "[", "selected_unit", "]", "min_value_input", ".", "setValue", "(", "default_min", ")", "min_value_input", ".", "setSingleStep", "(", "0.1", ")", "# Max label", "max_label", "=", "QLabel", "(", "tr", "(", "'Max <='", ")", ")", "# Max value as double spin", "max_value_input", "=", "QDoubleSpinBox", "(", ")", "# TODO(IS) We can set the min and max depends on the unit, later", "max_value_input", ".", "setMinimum", "(", "0", ")", "max_value_input", ".", "setMaximum", "(", "999999", ")", "if", "thresholds", ".", "get", "(", "the_class", "[", "'key'", "]", ")", ":", "max_value_input", ".", "setValue", "(", "thresholds", "[", "the_class", "[", "'key'", "]", "]", "[", "1", "]", ")", "else", ":", "default_max", "=", "the_class", "[", "'numeric_default_max'", "]", "if", "isinstance", "(", "default_max", ",", "dict", ")", ":", "default_max", "=", "the_class", "[", "'numeric_default_max'", "]", "[", "selected_unit", "]", "max_value_input", ".", "setValue", "(", "default_max", ")", "max_value_input", ".", "setSingleStep", "(", "0.1", ")", "# Add to class_layout", "class_layout", ".", "addWidget", "(", "min_label", ")", "class_layout", ".", "addWidget", "(", "min_value_input", ")", "# class_layout.addStretch(1)", "class_layout", ".", "addWidget", "(", "max_label", ")", "class_layout", ".", "addWidget", "(", "max_value_input", ")", "# Add to grid_layout", "self", ".", "gridLayoutThreshold", ".", "addWidget", "(", "class_label", ",", "i", ",", "0", ")", "self", ".", "gridLayoutThreshold", ".", "addLayout", "(", "class_layout", ",", "i", ",", "1", ")", "self", ".", "classes", "[", "the_class", "[", "'key'", "]", "]", "=", "[", "min_value_input", ",", "max_value_input", "]", "self", ".", "gridLayoutThreshold", ".", "setSpacing", "(", "0", ")", "def", "min_max_changed", "(", "index", ",", "the_string", ")", ":", "\"\"\"Slot when min or max value change.\n\n :param index: The index of the double spin.\n :type index: int\n\n :param the_string: The flag to indicate the min or max value.\n :type the_string: str\n \"\"\"", "if", "the_string", "==", "'Max value'", ":", "current_max_value", "=", "list", "(", "self", ".", "classes", ".", "values", "(", ")", ")", "[", "index", "]", "[", "1", "]", "target_min_value", "=", "list", "(", "self", ".", "classes", ".", "values", "(", ")", ")", "[", "index", "+", "1", "]", "[", "0", "]", "if", "current_max_value", ".", "value", "(", ")", "!=", "target_min_value", ".", "value", "(", ")", ":", "target_min_value", ".", "setValue", "(", "current_max_value", ".", "value", "(", ")", ")", "elif", "the_string", "==", "'Min value'", ":", "current_min_value", "=", "list", "(", "self", ".", "classes", ".", "values", "(", ")", ")", "[", "index", "]", "[", "0", "]", "target_max_value", "=", "list", "(", "self", ".", "classes", ".", "values", "(", ")", ")", "[", "index", "-", "1", "]", "[", "1", "]", "if", "current_min_value", ".", "value", "(", ")", "!=", "target_max_value", ".", "value", "(", ")", ":", "target_max_value", ".", "setValue", "(", "current_min_value", ".", "value", "(", ")", ")", "# Set behaviour", "for", "k", ",", "v", "in", "list", "(", "self", ".", "classes", ".", "items", "(", ")", ")", ":", "index", "=", "list", "(", "self", ".", "classes", ".", "keys", "(", ")", ")", ".", "index", "(", "k", ")", "if", "index", "<", "len", "(", "self", ".", "classes", ")", "-", "1", ":", "# Max value changed", "v", "[", "1", "]", ".", "valueChanged", ".", "connect", "(", "partial", "(", "min_max_changed", ",", "index", "=", "index", ",", "the_string", "=", "'Max value'", ")", ")", "if", "index", ">", "0", ":", "# Min value", "v", "[", "0", "]", ".", "valueChanged", ".", "connect", "(", "partial", "(", "min_max_changed", ",", "index", "=", "index", ",", "the_string", "=", "'Min value'", ")", ")" ]

[ "Called", "during", "each", "iteration", "of", "the", "event", "loop", "." ]

[ "def", "idle", "(", "self", ")", ":", "dt", "=", "self", ".", "clock", ".", "update_time", "(", ")", "redraw_all", "=", "self", ".", "clock", ".", "call_scheduled_functions", "(", "dt", ")", "# Redraw all windows", "for", "window", "in", "app", ".", "windows", ":", "if", "redraw_all", "or", "(", "window", ".", "_legacy_invalid", "and", "window", ".", "invalid", ")", ":", "window", ".", "switch_to", "(", ")", "window", ".", "dispatch_event", "(", "'on_draw'", ")", "window", ".", "flip", "(", ")", "window", ".", "_legacy_invalid", "=", "False", "# Update timout", "return", "self", ".", "clock", ".", "get_sleep_time", "(", "True", ")" ]

[ "Called", "when", "I", "finish", "joining", "a", "channel", "." ]

[ "def", "joined", "(", "self", ",", "channel", ")", ":" ]

[ "Forces", "a", "refresh", "of", "the", "access_token", "." ]

[ "def", "refresh", "(", "self", ",", "http", ")", ":", "self", ".", "_refresh", "(", "http", ".", "request", ")" ]

[ "Paginate", "the", "queryset", "if", "needed", "." ]

[ "def", "paginate_queryset", "(", "self", ",", "queryset", ",", "page_size", ")", ":", "paginator", "=", "self", ".", "get_paginator", "(", "queryset", ",", "page_size", ",", "orphans", "=", "self", ".", "get_paginate_orphans", "(", ")", ",", "allow_empty_first_page", "=", "self", ".", "get_allow_empty", "(", ")", ")", "page_kwarg", "=", "self", ".", "page_kwarg", "page", "=", "self", ".", "kwargs", ".", "get", "(", "page_kwarg", ")", "or", "self", ".", "request", ".", "GET", ".", "get", "(", "page_kwarg", ")", "or", "1", "try", ":", "page_number", "=", "int", "(", "page", ")", "except", "ValueError", ":", "if", "page", "==", "'last'", ":", "page_number", "=", "paginator", ".", "num_pages", "else", ":", "raise", "Http404", "(", "_", "(", "\"Page is not 'last', nor can it be converted to an int.\"", ")", ")", "try", ":", "page", "=", "paginator", ".", "page", "(", "page_number", ")", "return", "(", "paginator", ",", "page", ",", "page", ".", "object_list", ",", "page", ".", "has_other_pages", "(", ")", ")", "except", "InvalidPage", "as", "e", ":", "raise", "Http404", "(", "_", "(", "'Invalid page (%(page_number)s): %(message)s'", ")", "%", "{", "'page_number'", ":", "page_number", ",", "'message'", ":", "force_text", "(", "e", ")", ",", "}", ")" ]

[ "Insertion", "sort", "apply", "this", "method", "with", "certain", "size", "array", "to", "improve", "performance", "." ]

[ "def", "insertion_sort", "(", "self", ",", "seq", ":", "MutableSequence", "[", "CT", "]", ",", "low", ":", "int", ",", "high", ":", "int", ")", "->", "None", ":", "for", "i", "in", "range", "(", "low", "+", "1", ",", "high", "+", "1", ")", ":", "j", "=", "i", "while", "j", ">", "low", "and", "seq", "[", "j", "]", "<", "seq", "[", "j", "-", "1", "]", ":", "self", ".", "exch", "(", "seq", ",", "j", ",", "j", "-", "1", ")", "j", "-=", "1" ]

[ "r", "Computes", "Renyi", "Differential", "Privacy", "(", "RDP", ")", "guarantees", "of", "the", "Sampled", "Gaussian", "Mechanism", "(", "SGM", ")", "iterated", "steps", "times", "." ]

[ "def", "compute_rdp", "(", "*", ",", "q", ":", "float", ",", "noise_multiplier", ":", "float", ",", "steps", ":", "int", ",", "orders", ":", "Union", "[", "List", "[", "float", "]", ",", "float", "]", ")", "->", "Union", "[", "List", "[", "float", "]", ",", "float", "]", ":", "if", "isinstance", "(", "orders", ",", "float", ")", ":", "rdp", "=", "_compute_rdp", "(", "q", ",", "noise_multiplier", ",", "orders", ")", "else", ":", "rdp", "=", "np", ".", "array", "(", "[", "_compute_rdp", "(", "q", ",", "noise_multiplier", ",", "order", ")", "for", "order", "in", "orders", "]", ")", "return", "rdp", "*", "steps" ]

[ "Gets", "the", "current", "metric", "values" ]

[ "def", "getMetrics", "(", "self", ")", ":", "result", "=", "{", "}", "for", "metricObj", ",", "label", "in", "zip", "(", "self", ".", "__metrics", ",", "self", ".", "__metricLabels", ")", ":", "value", "=", "metricObj", ".", "getMetric", "(", ")", "result", "[", "label", "]", "=", "value", "[", "'value'", "]", "return", "result" ]

[ "Invokes", "tuner", "fit", "algorithm", "." ]

[ "def", "fit", "(", "self", ",", "*", "fit_args", ",", "*", "*", "fit_kwargs", ")", ":", "callbacks", "=", "fit_kwargs", ".", "get", "(", "\"callbacks\"", ",", "None", ")", "if", "callbacks", "is", "None", ":", "callbacks", "=", "[", "]", "epochs", "=", "fit_kwargs", ".", "get", "(", "\"epochs\"", ",", "None", ")", "if", "epochs", "is", "None", ":", "epochs", "=", "10", "if", "not", "self", ".", "_has_earlystopping", "(", "callbacks", ")", ":", "callbacks", "=", "callbacks", "+", "[", "tf", ".", "keras", ".", "callbacks", ".", "EarlyStopping", "(", "\"val_loss\"", ",", "patience", "=", "min", "(", "20", ",", "epochs", "//", "5", ")", ")", "]", "fit_kwargs", "[", "\"callbacks\"", "]", "=", "callbacks", "self", ".", "tuner", ".", "search", "(", "*", "fit_args", ",", "*", "*", "fit_kwargs", ")" ]

[ "Take", "an", "object", "and", "test", "to", "see", "if", "it", "can", "be", "represented", "as", "a", "dictionary", ".", "Unless", "it", "can", "not", "be", "represented", "as", "such", "return", "an", "OrderedDict", "e", ".", "g", "." ]

[ "def", "from_key_val_list", "(", "value", ")", ":", "if", "value", "is", "None", ":", "return", "None", "if", "isinstance", "(", "value", ",", "(", "str", ",", "bytes", ",", "bool", ",", "int", ")", ")", ":", "raise", "ValueError", "(", "'cannot encode objects that are not 2-tuples'", ")", "return", "OrderedDict", "(", "value", ")" ]

[ "Return", "true", "if", "the", "member", "/", "parameter", "ElementTree", "passed", "is", "from", "this", "API", "." ]

[ "def", "is_api_type", "(", "self", ",", "member_elem", ")", ":", "membertext", "=", "\"\"", ".", "join", "(", "member_elem", ".", "itertext", "(", ")", ")", "return", "self", ".", "conventions", ".", "type_prefix", "in", "membertext" ]

[ "Renders", "a", "mako", "template", "to", "HTML", "and", "sets", "the", "CherryPy", "response", "s", "body", "with", "it", "." ]

[ "def", "render_template", "(", "template", ")", ":", "if", "cherrypy", ".", "response", ".", "status", ">", "399", ":", "return", "data", "=", "cherrypy", ".", "response", ".", "body", "or", "{", "}", "template", "=", "lookup", ".", "get_template", "(", "template", ")", "if", "template", "and", "isinstance", "(", "data", ",", "dict", ")", ":", "cherrypy", ".", "response", ".", "body", "=", "template", ".", "render", "(", "*", "*", "data", ")" ]

[]

[ "def", "__init__", "(", "self", ",", "data", ")", ":", "# loop through data", "for", "x", "in", "data", ":", "# set information as correct data type", "try", ":", "setattr", "(", "self", ",", "x", ",", "int", "(", "data", "[", "x", "]", ")", ")", "except", "ValueError", ":", "try", ":", "setattr", "(", "self", ",", "x", ",", "float", "(", "data", "[", "x", "]", ")", ")", "except", "ValueError", ":", "# string if not number", "setattr", "(", "self", ",", "x", ",", "str", "(", "data", "[", "x", "]", ")", ")", "except", "TypeError", ":", "obj", "=", "nhl_api", ".", "object", ".", "Object", "(", "data", "[", "x", "]", ")", "setattr", "(", "self", ",", "x", ",", "obj", ")", "# calculate the winning team", "if", "self", ".", "home_score", ">", "self", ".", "away_score", ":", "self", ".", "w_team", "=", "self", ".", "home_team_id", "self", ".", "w_score", "=", "self", ".", "home_score", "self", ".", "l_team", "=", "self", ".", "away_team_id", "self", ".", "l_score", "=", "self", ".", "away_score", "elif", "self", ".", "away_score", ">", "self", ".", "home_score", ":", "self", ".", "w_team", "=", "self", ".", "away_team_id", "self", ".", "w_score", "=", "self", ".", "away_score", "self", ".", "l_team", "=", "self", ".", "home_team_id", "self", ".", "l_score", "=", "self", ".", "home_score" ]

[]

[ "def", "resolve", "(", "module_name", ",", "dotted_path", ")", ":", "if", "module_name", "in", "sys", ".", "modules", ":", "mod", "=", "sys", ".", "modules", "[", "module_name", "]", "else", ":", "mod", "=", "__import__", "(", "module_name", ")", "if", "dotted_path", "is", "None", ":", "result", "=", "mod", "else", ":", "parts", "=", "dotted_path", ".", "split", "(", "'.'", ")", "result", "=", "getattr", "(", "mod", ",", "parts", ".", "pop", "(", "0", ")", ")", "for", "p", "in", "parts", ":", "result", "=", "getattr", "(", "result", ",", "p", ")", "return", "result" ]

[]

[ "async", "def", "_send_bridge_error", "(", "self", ",", "sender", ":", "u", ".", "User", ",", "err", ":", "Exception", ",", "event_id", ":", "EventID", ",", "event_type", ":", "EventType", ",", "message_type", ":", "MessageType", "|", "None", "=", "None", ",", "msg", ":", "str", "|", "None", "=", "None", ",", ")", "->", "None", ":", "sender", ".", "send_remote_checkpoint", "(", "MessageSendCheckpointStatus", ".", "PERM_FAILURE", ",", "event_id", ",", "self", ".", "mxid", ",", "event_type", ",", "message_type", "=", "message_type", ",", "error", "=", "err", ",", ")", "if", "msg", "and", "self", ".", "config", "[", "\"bridge.delivery_error_reports\"", "]", ":", "await", "self", ".", "_send_message", "(", "self", ".", "main_intent", ",", "TextMessageEventContent", "(", "msgtype", "=", "MessageType", ".", "NOTICE", ",", "body", "=", "msg", ")", ")" ]

[]

[ "def", "__init__", "(", "self", ",", "context", ",", "request", ",", "fieldvalue", "=", "[", "]", ",", "allow_edit", "=", "False", ")", ":", "super", "(", "ARTemplateAnalysesView", ",", "self", ")", ".", "__init__", "(", "context", ",", "request", ")", "self", ".", "catalog", "=", "\"bika_setup_catalog\"", "self", ".", "contentFilter", "=", "{", "'portal_type'", ":", "'AnalysisService'", ",", "'sort_on'", ":", "'sortable_title'", ",", "'inactive_state'", ":", "'active'", ",", "}", "self", ".", "context_actions", "=", "{", "}", "self", ".", "base_url", "=", "self", ".", "context", ".", "absolute_url", "(", ")", "self", ".", "view_url", "=", "self", ".", "base_url", "self", ".", "show_sort_column", "=", "False", "self", ".", "show_select_row", "=", "False", "self", ".", "show_select_all_checkbox", "=", "False", "self", ".", "show_column_toggles", "=", "False", "self", ".", "show_select_column", "=", "True", "self", ".", "pagesize", "=", "999999", "self", ".", "allow_edit", "=", "allow_edit", "self", ".", "form_id", "=", "\"analyses\"", "self", ".", "categories", "=", "[", "]", "self", ".", "do_cats", "=", "self", ".", "context", ".", "bika_setup", ".", "getCategoriseAnalysisServices", "(", ")", "if", "self", ".", "do_cats", ":", "self", ".", "pagesize", "=", "999999", "# hide batching controls", "self", ".", "show_categories", "=", "True", "self", ".", "expand_all_categories", "=", "False", "self", ".", "ajax_categories", "=", "True", "self", ".", "ajax_categories_url", "=", "self", ".", "context", ".", "absolute_url", "(", ")", "+", "\"/artemplate_analysesview\"", "self", ".", "category_index", "=", "'getCategoryTitle'", "self", ".", "columns", "=", "{", "'Title'", ":", "{", "'title'", ":", "_", "(", "'Service'", ")", ",", "'index'", ":", "'sortable_title'", ",", "'sortable'", ":", "False", ",", "}", ",", "'Price'", ":", "{", "'title'", ":", "_", "(", "'Price'", ")", ",", "'sortable'", ":", "False", ",", "}", ",", "'Partition'", ":", "{", "'title'", ":", "_", "(", "'Partition'", ")", ",", "'sortable'", ":", "False", ",", "}", ",", "}", "self", ".", "review_states", "=", "[", "{", "'id'", ":", "'default'", ",", "'title'", ":", "_", "(", "'All'", ")", ",", "'contentFilter'", ":", "{", "}", ",", "'columns'", ":", "[", "'Title'", ",", "'Price'", ",", "'Partition'", ",", "]", ",", "'transitions'", ":", "[", "{", "'id'", ":", "'empty'", "}", ",", "]", ",", "# none", "}", ",", "]", "if", "not", "self", ".", "context", ".", "bika_setup", ".", "getShowPrices", "(", ")", ":", "self", ".", "review_states", "[", "0", "]", "[", "'columns'", "]", ".", "remove", "(", "'Price'", ")", "self", ".", "fieldvalue", "=", "fieldvalue", "self", ".", "selected", "=", "[", "x", "[", "'service_uid'", "]", "for", "x", "in", "fieldvalue", "]", "if", "self", ".", "aq_parent", ".", "portal_type", "==", "'ARTemplate'", ":", "# Custom settings for the Analysis Services assigned to", "# the Analysis Request Template", "# https://jira.bikalabs.com/browse/LIMS-1324", "self", ".", "artemplate", "=", "self", ".", "aq_parent", "self", ".", "columns", "[", "'Hidden'", "]", "=", "{", "'title'", ":", "_", "(", "'Hidden'", ")", ",", "'sortable'", ":", "False", ",", "'type'", ":", "'boolean'", "}", "self", ".", "review_states", "[", "0", "]", "[", "'columns'", "]", ".", "insert", "(", "1", ",", "'Hidden'", ")" ]

[]

[ "def", "smooth_l1_loss_rcnn", "(", "bbox_pred", ",", "bbox_targets", ",", "label", ",", "num_classes", ",", "sigma", "=", "1.0", ")", ":", "outside_mask", "=", "tf", ".", "stop_gradient", "(", "tf", ".", "to_float", "(", "tf", ".", "greater", "(", "label", ",", "0", ")", ")", ")", "bbox_pred", "=", "tf", ".", "reshape", "(", "bbox_pred", ",", "[", "-", "1", ",", "num_classes", ",", "5", "]", ")", "bbox_targets", "=", "tf", ".", "reshape", "(", "bbox_targets", ",", "[", "-", "1", ",", "num_classes", ",", "5", "]", ")", "value", "=", "_smooth_l1_loss_base", "(", "bbox_pred", ",", "bbox_targets", ",", "sigma", "=", "sigma", ")", "value", "=", "tf", ".", "reduce_sum", "(", "value", ",", "2", ")", "value", "=", "tf", ".", "reshape", "(", "value", ",", "[", "-", "1", ",", "num_classes", "]", ")", "inside_mask", "=", "tf", ".", "one_hot", "(", "tf", ".", "reshape", "(", "label", ",", "[", "-", "1", ",", "1", "]", ")", ",", "depth", "=", "num_classes", ",", "axis", "=", "1", ")", "inside_mask", "=", "tf", ".", "stop_gradient", "(", "tf", ".", "to_float", "(", "tf", ".", "reshape", "(", "inside_mask", ",", "[", "-", "1", ",", "num_classes", "]", ")", ")", ")", "normalizer", "=", "tf", ".", "to_float", "(", "tf", ".", "shape", "(", "bbox_pred", ")", "[", "0", "]", ")", "bbox_loss", "=", "tf", ".", "reduce_sum", "(", "tf", ".", "reduce_sum", "(", "value", "*", "inside_mask", ",", "1", ")", "*", "outside_mask", ")", "/", "normalizer", "return", "bbox_loss" ]

[ "Run", "function", "func", "in", "a", "separate", "killable", "process", "." ]

[ "def", "_killable_process", "(", "self", ",", "func", ",", "*", "args", ",", "*", "*", "kwargs", ")", ":", "with", "multiprocessing", ".", "Pool", "(", "1", ")", "as", "process", ":", "result_obj", "=", "process", ".", "apply_async", "(", "func", ",", "args", ",", "kwargs", ")", "self", ".", "abort_current_task", "=", "process", ".", "terminate", "result", "=", "result_obj", ".", "get", "(", ")", "# Wait process end & re-raise exceptions", "self", ".", "abort_current_task", "=", "None", "logger", ".", "debug", "(", "\"Process %s returned: %s\"", ",", "func", ",", "result", ")", "return", "result" ]

[ "Return", "a", "splitter", "function", "suitable", "for", "a", "given", "set", "of", "data", "." ]

[ "def", "makeSplitter", "(", "lstrip", "=", "None", ",", "sep", "=", "'|'", ",", "comments", "=", "True", ",", "origNotesSep", "=", "' ('", ",", "newNotesSep", "=", "'::('", ",", "strip", "=", "None", ")", ":", "def", "splitter", "(", "x", ")", ":", "if", "not", "x", ":", "return", "x", "x", "=", "x", ".", "strip", "(", ")", "if", "not", "x", ":", "return", "x", "if", "lstrip", "is", "not", "None", ":", "x", "=", "x", ".", "lstrip", "(", "lstrip", ")", ".", "lstrip", "(", ")", "lx", "=", "x", ".", "split", "(", "sep", ")", "lx", "[", ":", "]", "=", "[", "_f", "for", "_f", "in", "[", "j", ".", "strip", "(", ")", "for", "j", "in", "lx", "]", "if", "_f", "]", "if", "comments", ":", "lx", "[", ":", "]", "=", "[", "j", ".", "replace", "(", "origNotesSep", ",", "newNotesSep", ",", "1", ")", "for", "j", "in", "lx", "]", "if", "strip", ":", "lx", "[", ":", "]", "=", "[", "j", ".", "strip", "(", "strip", ")", "for", "j", "in", "lx", "]", "return", "lx", "return", "splitter" ]

[ "Optimises", "a", "function", "by", "randomly", "sampling", "and", "choosing", "its", "maximum", "." ]

[ "def", "random_sample", "(", "obj", ",", "bounds", ",", "max_evals", ",", "vectorised", "=", "True", ")", ":", "dim", "=", "len", "(", "bounds", ")", "rand_pts", "=", "map_to_bounds", "(", "np", ".", "random", ".", "random", "(", "(", "int", "(", "max_evals", ")", ",", "dim", ")", ")", ",", "bounds", ")", "if", "vectorised", ":", "obj_vals", "=", "obj", "(", "rand_pts", ")", "else", ":", "obj_vals", "=", "np", ".", "array", "(", "[", "obj", "(", "x", ")", "for", "x", "in", "rand_pts", "]", ")", "return", "rand_pts", ",", "obj_vals" ]

[ "Returns", "True", "if", "the", "currently", "set", "font", "for", "the", "footer", "item", "is", "valid", "." ]

[ "def", "HasFooterFont", "(", "self", ")", ":", "return", "self", ".", "_footerFont", ".", "IsOk", "(", ")" ]

[ "Determine", "is", "a", "migration", "is", "in", "progress", "." ]

[ "def", "async_migration_in_progress", "(", "hass", ":", "HomeAssistant", ")", "->", "bool", ":", "if", "DATA_INSTANCE", "not", "in", "hass", ".", "data", ":", "return", "False", "return", "hass", ".", "data", "[", "DATA_INSTANCE", "]", ".", "migration_in_progress" ]

[ "Prepare", "the", "SOAP", "message", "for", "sending", "to", "the", "server", "." ]

[ "def", "prepare", "(", "self", ")", ":", "headers", "=", "self", ".", "prepare_headers", "(", "self", ".", "http_headers", ",", "self", ".", "soap_action", ")", "soap_header", "=", "self", ".", "prepare_soap_header", "(", "self", ".", "soap_header", ")", "soap_body", "=", "self", ".", "prepare_soap_body", "(", "self", ".", "method", ",", "self", ".", "parameters", ",", "self", ".", "namespace", ")", "data", "=", "self", ".", "prepare_soap_envelope", "(", "soap_header", ",", "soap_body", ")", "return", "(", "headers", ",", "data", ")" ]

[ "!" ]

[ "def", "som_get_awards", "(", "som_pointer", ")", ":", "ccore", "=", "ccore_library", ".", "get", "(", ")", "ccore", ".", "som_get_awards", ".", "restype", "=", "POINTER", "(", "pyclustering_package", ")", "package", "=", "ccore", ".", "som_get_awards", "(", "som_pointer", ")", "result", "=", "package_extractor", "(", "package", ")", ".", "extract", "(", ")", "return", "result" ]

[ "Set", "values", "set", "filter", ".", "Only", "match", "records", "where", "attribute", "value", "is", "in", "given", "values", "set", "." ]

[ "def", "SetFilter", "(", "self", ",", "attribute", ",", "values", ",", "exclude", "=", "0", ")", ":", "assert", "(", "isinstance", "(", "attribute", ",", "str", ")", ")", "assert", "iter", "(", "values", ")", "for", "value", "in", "values", ":", "assert", "(", "isinstance", "(", "value", ",", "(", "int", ",", "long", ")", ")", ")", "self", ".", "_filters", ".", "append", "(", "{", "'type'", ":", "SPH_FILTER_VALUES", ",", "'attr'", ":", "attribute", ",", "'exclude'", ":", "exclude", ",", "'values'", ":", "values", "}", ")" ]