Datasets:

shahp7575

/

sia_pile_sample

like 1

[ "RFC", "5987", "(", "8187", ")", "(", "specialized", "from", "RFC", "2231", ")", "parameter", "encoding", "." ]

[ "def", "encode_params", "(", "value", ")", ":", "params", "=", "[", "]", "for", "p", "in", "_parseparam", "(", "\";\"", "+", "value", ")", ":", "p", "=", "p", ".", "strip", "(", ")", "if", "not", "p", ":", "continue", "params", ".", "append", "(", "[", "s", ".", "strip", "(", ")", "for", "s", "in", "p", ".", "split", "(", "\"=\"", ",", "1", ")", "]", ")", "known_params", "=", "{", "p", "[", "0", "]", "for", "p", "in", "params", "}", "for", "p", "in", "params", "[", ":", "]", ":", "if", "len", "(", "p", ")", "==", "2", "and", "non_latin_1", "(", "p", "[", "1", "]", ")", ":", "# need encoding", "pn", "=", "p", "[", "0", "]", "pnc", "=", "pn", "+", "\"*\"", "pv", "=", "p", "[", "1", "]", "if", "pnc", "not", "in", "known_params", ":", "if", "pv", ".", "startswith", "(", "'\"'", ")", ":", "pv", "=", "pv", "[", "1", ":", "-", "1", "]", "# remove quotes", "params", ".", "append", "(", "(", "pnc", ",", "encode_rfc2231", "(", "pv", ",", "\"utf-8\"", ",", "None", ")", ")", ")", "# backward compatibility for clients not understanding RFC 5987", "p", "[", "1", "]", "=", "p", "[", "1", "]", ".", "encode", "(", "\"iso-8859-1\"", ",", "\"replace\"", ")", ".", "decode", "(", "\"iso-8859-1\"", ")", "return", "\"; \"", ".", "join", "(", "\"=\"", ".", "join", "(", "p", ")", "for", "p", "in", "params", ")" ]

[ "Create", "a", "new", "response", "using", "the", "given", "values", "." ]

[ "def", "__init__", "(", "self", ",", "body", "=", "b''", ",", "status", "=", "200", ",", "headers", "=", "None", ",", "stdout", "=", "None", ",", "stderr", "=", "None", ")", ":", "self", ".", "accumulated_headers", "=", "[", "]", "self", ".", "cookies", "=", "{", "}", "self", ".", "headers", "=", "{", "}", "if", "headers", "is", "not", "None", ":", "for", "key", ",", "value", "in", "headers", ".", "items", "(", ")", ":", "self", ".", "setHeader", "(", "key", ",", "value", ")", "self", ".", "setStatus", "(", "status", ")", "if", "stdout", "is", "None", ":", "stdout", "=", "BytesIO", "(", ")", "self", ".", "stdout", "=", "stdout", "if", "stderr", "is", "None", ":", "stderr", "=", "BytesIO", "(", ")", "self", ".", "stderr", "=", "stderr", "if", "body", ":", "self", ".", "setBody", "(", "body", ")" ]

[ "Cause", "a", "redirection", "without", "raising", "an", "error" ]

[ "def", "redirect", "(", "self", ",", "location", ",", "status", "=", "302", ",", "lock", "=", "0", ")", ":", "if", "isinstance", "(", "location", ",", "HTTPRedirection", ")", ":", "status", "=", "location", ".", "getStatus", "(", ")", "location", "=", "location", ".", "headers", "[", "'Location'", "]", "if", "isinstance", "(", "location", ",", "bytes", ")", ":", "location", "=", "location", ".", "decode", "(", "self", ".", "charset", ")", "# To be entirely correct, we must make sure that all non-ASCII", "# characters in the path part are quoted correctly. This is required", "# as we now allow non-ASCII IDs", "parsed", "=", "list", "(", "urlparse", "(", "location", ")", ")", "# Make a hacky guess whether the path component is already", "# URL-encoded by checking for %. If it is, we don't touch it.", "if", "'%'", "not", "in", "parsed", "[", "2", "]", ":", "# The list of \"safe\" characters is from RFC 2396 section 2.3", "# (unreserved characters that should not be escaped) plus", "# section 3.3 (reserved characters in path components)", "parsed", "[", "2", "]", "=", "quote", "(", "parsed", "[", "2", "]", ",", "safe", "=", "\"/@!*'~();,=+$\"", ")", "location", "=", "urlunparse", "(", "parsed", ")", "self", ".", "setStatus", "(", "status", ",", "lock", "=", "lock", ")", "self", ".", "setHeader", "(", "'Location'", ",", "location", ")", "return", "location" ]

[ "Return", "a", "cloned", "response", "object", "to", "be", "used", "in", "a", "retry", "attempt", "." ]

[ "def", "retry", "(", "self", ")", ":", "# This implementation is a bit lame, because it assumes that", "# only stdout stderr were passed to the constructor. OTOH, I", "# think that that's all that is ever passed.", "return", "self", ".", "__class__", "(", "stdout", "=", "self", ".", "stdout", ",", "stderr", "=", "self", ".", "stderr", ")" ]

[ "Set", "the", "HTTP", "status", "code", "of", "the", "response" ]

[ "def", "setStatus", "(", "self", ",", "status", ",", "reason", "=", "None", ",", "lock", "=", "None", ")", ":", "if", "self", ".", "_locked_status", ":", "# Don't change the response status.", "# It has already been determined.", "return", "if", "isinstance", "(", "status", ",", "type", ")", "and", "issubclass", "(", "status", ",", "Exception", ")", ":", "status", "=", "status", ".", "__name__", "if", "isinstance", "(", "status", ",", "str", ")", ":", "status", "=", "status", ".", "lower", "(", ")", "if", "status", "in", "status_codes", ":", "status", "=", "status_codes", "[", "status", "]", "else", ":", "status", "=", "500", "self", ".", "status", "=", "status", "if", "reason", "is", "None", ":", "if", "status", "in", "status_reasons", ":", "reason", "=", "status_reasons", "[", "status", "]", "else", ":", "reason", "=", "'Unknown'", "self", ".", "errmsg", "=", "reason", "# lock the status if we're told to", "if", "lock", ":", "self", ".", "_locked_status", "=", "1" ]

[ "Set", "an", "HTTP", "cookie", "." ]

[ "def", "setCookie", "(", "self", ",", "name", ",", "value", ",", "quoted", "=", "True", ",", "*", "*", "kw", ")", ":", "cookies", "=", "self", ".", "cookies", "if", "name", "in", "cookies", ":", "cookie", "=", "cookies", "[", "name", "]", "else", ":", "cookie", "=", "cookies", "[", "name", "]", "=", "{", "}", "for", "k", ",", "v", "in", "kw", ".", "items", "(", ")", ":", "cookie", "[", "k", "]", "=", "v", "cookie", "[", "'value'", "]", "=", "value", "cookie", "[", "'quoted'", "]", "=", "quoted" ]

[ "Set", "an", "HTTP", "cookie", "." ]

[ "def", "appendCookie", "(", "self", ",", "name", ",", "value", ")", ":", "cookies", "=", "self", ".", "cookies", "if", "name", "in", "cookies", ":", "cookie", "=", "cookies", "[", "name", "]", "else", ":", "cookie", "=", "cookies", "[", "name", "]", "=", "{", "}", "if", "'value'", "in", "cookie", ":", "cookie", "[", "'value'", "]", "=", "f'{cookie[\"value\"]}:{value}'", "else", ":", "cookie", "[", "'value'", "]", "=", "value" ]

[ "Clear", "an", "HTTP", "cookie", "." ]

[ "def", "expireCookie", "(", "self", ",", "name", ",", "*", "*", "kw", ")", ":", "d", "=", "kw", ".", "copy", "(", ")", "if", "'value'", "in", "d", ":", "d", ".", "pop", "(", "'value'", ")", "d", "[", "'max_age'", "]", "=", "0", "d", "[", "'expires'", "]", "=", "'Wed, 31 Dec 1997 23:59:59 GMT'", "self", ".", "setCookie", "(", "name", ",", "value", "=", "'deleted'", ",", "*", "*", "d", ")" ]

[ "Get", "a", "previously", "set", "header", "value", "." ]

[ "def", "getHeader", "(", "self", ",", "name", ",", "literal", "=", "0", ")", ":", "key", "=", "literal", "and", "name", "or", "name", ".", "lower", "(", ")", "return", "self", ".", "headers", ".", "get", "(", "key", ",", "None", ")" ]

[ "Set", "an", "HTTP", "return", "header", "on", "the", "response", "." ]

[ "def", "setHeader", "(", "self", ",", "name", ",", "value", ",", "literal", "=", "0", ",", "scrubbed", "=", "False", ")", ":", "if", "not", "scrubbed", ":", "name", ",", "value", "=", "_scrubHeader", "(", "name", ",", "value", ")", "key", "=", "name", ".", "lower", "(", ")", "if", "key", "==", "'content-type'", ":", "if", "'charset'", "in", "value", ":", "# Update self.charset with the charset from the header", "match", "=", "charset_re_match", "(", "value", ")", "if", "match", ":", "self", ".", "charset", "=", "match", ".", "group", "(", "1", ")", "else", ":", "# Update the header value with self.charset", "if", "value", ".", "startswith", "(", "'text/'", ")", ":", "value", "=", "value", "+", "'; charset='", "+", "self", ".", "charset", "name", "=", "literal", "and", "name", "or", "key", "self", ".", "headers", "[", "name", "]", "=", "value" ]

[ "Append", "a", "value", "to", "an", "HTTP", "return", "header", "." ]

[ "def", "appendHeader", "(", "self", ",", "name", ",", "value", ",", "delimiter", "=", "\", \"", ")", ":", "name", ",", "value", "=", "_scrubHeader", "(", "name", ",", "value", ")", "name", "=", "name", ".", "lower", "(", ")", "headers", "=", "self", ".", "headers", "if", "name", "in", "headers", ":", "h", "=", "headers", "[", "name", "]", "h", "=", "f\"{h}{delimiter}{value}\"", "else", ":", "h", "=", "value", "self", ".", "setHeader", "(", "name", ",", "h", ",", "scrubbed", "=", "True", ")" ]

[ "Set", "a", "new", "HTTP", "return", "header", "with", "the", "given", "value" ]

[ "def", "addHeader", "(", "self", ",", "name", ",", "value", ")", ":", "name", ",", "value", "=", "_scrubHeader", "(", "name", ",", "value", ")", "self", ".", "accumulated_headers", ".", "append", "(", "(", "name", ",", "value", ")", ")" ]

[ "Set", "the", "base", "URL", "for", "the", "returned", "document", "." ]

[ "def", "setBase", "(", "self", ",", "base", ")", ":", "if", "base", "is", "None", ":", "base", "=", "''", "elif", "not", "base", ".", "endswith", "(", "'/'", ")", ":", "base", "=", "base", "+", "'/'", "self", ".", "base", "=", "str", "(", "base", ")" ]

[ "Set", "the", "body", "of", "the", "response" ]

[ "def", "setBody", "(", "self", ",", "body", ",", "title", "=", "''", ",", "is_error", "=", "False", ",", "lock", "=", "None", ")", ":", "# allow locking of the body in the same way as the status", "if", "self", ".", "_locked_body", ":", "return", "elif", "lock", ":", "self", ".", "_locked_body", "=", "1", "if", "not", "body", ":", "return", "self", "if", "isinstance", "(", "body", ",", "tuple", ")", "and", "len", "(", "body", ")", "==", "2", ":", "title", ",", "body", "=", "body", "if", "hasattr", "(", "body", ",", "'asHTML'", ")", ":", "body", "=", "body", ".", "asHTML", "(", ")", "if", "isinstance", "(", "body", ",", "str", ")", ":", "body", "=", "self", ".", "_encode_unicode", "(", "body", ")", "elif", "isinstance", "(", "body", ",", "bytes", ")", ":", "pass", "else", ":", "try", ":", "body", "=", "bytes", "(", "body", ")", "except", "(", "TypeError", ",", "UnicodeError", ")", ":", "body", "=", "self", ".", "_encode_unicode", "(", "str", "(", "body", ")", ")", "# At this point body is always binary", "b_len", "=", "len", "(", "body", ")", "if", "b_len", "<", "200", "and", "body", "[", ":", "1", "]", "==", "b'<'", "and", "body", ".", "find", "(", "b'>'", ")", "==", "b_len", "-", "1", "and", "bogus_str_search", "(", "body", ")", "is", "not", "None", ":", "self", ".", "notFoundError", "(", "body", "[", "1", ":", "-", "1", "]", ".", "decode", "(", "self", ".", "charset", ")", ")", "else", ":", "if", "title", ":", "title", "=", "str", "(", "title", ")", "if", "not", "is_error", ":", "self", ".", "body", "=", "body", "=", "self", ".", "_html", "(", "title", ",", "body", ".", "decode", "(", "self", ".", "charset", ")", ")", ".", "encode", "(", "self", ".", "charset", ")", "else", ":", "self", ".", "body", "=", "body", "=", "self", ".", "_error_html", "(", "title", ",", "body", ".", "decode", "(", "self", ".", "charset", ")", ")", ".", "encode", "(", "self", ".", "charset", ")", "else", ":", "self", ".", "body", "=", "body", "content_type", "=", "self", ".", "headers", ".", "get", "(", "'content-type'", ")", "if", "content_type", "is", "None", ":", "if", "self", ".", "isHTML", "(", "body", ")", ":", "content_type", "=", "f'text/html; charset={self.charset}'", "else", ":", "content_type", "=", "f'text/plain; charset={self.charset}'", "self", ".", "setHeader", "(", "'content-type'", ",", "content_type", ")", "else", ":", "if", "content_type", ".", "startswith", "(", "'text/'", ")", "and", "'charset='", "not", "in", "content_type", ":", "content_type", "=", "f'{content_type}; charset={self.charset}'", "self", ".", "setHeader", "(", "'content-type'", ",", "content_type", ")", "self", ".", "setHeader", "(", "'content-length'", ",", "len", "(", "self", ".", "body", ")", ")", "self", ".", "insertBase", "(", ")", "if", "self", ".", "use_HTTP_content_compression", "and", "self", ".", "headers", ".", "get", "(", "'content-encoding'", ",", "'gzip'", ")", "==", "'gzip'", ":", "# use HTTP content encoding to compress body contents unless", "# this response already has another type of content encoding", "if", "content_type", ".", "split", "(", "'/'", ")", "[", "0", "]", "not", "in", "uncompressableMimeMajorTypes", ":", "# only compress if not listed as uncompressable", "body", "=", "self", ".", "body", "startlen", "=", "len", "(", "body", ")", "co", "=", "zlib", ".", "compressobj", "(", "6", ",", "zlib", ".", "DEFLATED", ",", "-", "zlib", ".", "MAX_WBITS", ",", "zlib", ".", "DEF_MEM_LEVEL", ",", "0", ")", "chunks", "=", "[", "_gzip_header", ",", "co", ".", "compress", "(", "body", ")", ",", "co", ".", "flush", "(", ")", ",", "struct", ".", "pack", "(", "\"<LL\"", ",", "zlib", ".", "crc32", "(", "body", ")", "&", "0xffffffff", ",", "startlen", ")", "]", "z", "=", "b''", ".", "join", "(", "chunks", ")", "newlen", "=", "len", "(", "z", ")", "if", "newlen", "<", "startlen", ":", "self", ".", "body", "=", "z", "self", ".", "setHeader", "(", "'content-length'", ",", "newlen", ")", "self", ".", "setHeader", "(", "'content-encoding'", ",", "'gzip'", ")", "if", "self", ".", "use_HTTP_content_compression", "==", "1", ":", "# use_HTTP_content_compression == 1 if force was", "# NOT used in enableHTTPCompression().", "# If we forced it, then Accept-Encoding", "# was ignored anyway, so cache should not", "# vary on it. Otherwise if not forced, cache should", "# respect Accept-Encoding client header", "vary", "=", "self", ".", "getHeader", "(", "'Vary'", ")", "if", "vary", "is", "None", "or", "'Accept-Encoding'", "not", "in", "vary", ":", "self", ".", "appendHeader", "(", "'Vary'", ",", "'Accept-Encoding'", ")", "return", "self" ]

[ "Enable", "HTTP", "Content", "Encoding", "with", "gzip", "compression", "if", "possible" ]

[ "def", "enableHTTPCompression", "(", "self", ",", "REQUEST", "=", "{", "}", ",", "force", "=", "0", ",", "disable", "=", "0", ",", "query", "=", "0", ")", ":", "if", "query", ":", "return", "self", ".", "use_HTTP_content_compression", "elif", "disable", ":", "# in the future, a gzip cache manager will need to ensure that", "# compression is off", "self", ".", "use_HTTP_content_compression", "=", "0", "elif", "force", "or", "'gzip'", "in", "REQUEST", ".", "get", "(", "'HTTP_ACCEPT_ENCODING'", ",", "''", ")", ":", "if", "force", ":", "self", ".", "use_HTTP_content_compression", "=", "2", "else", ":", "self", ".", "use_HTTP_content_compression", "=", "1", "return", "self", ".", "use_HTTP_content_compression" ]

[ "Return", "a", "list", "of", "(", "key", "value", ")", "pairs", "for", "our", "headers", "." ]

[ "def", "listHeaders", "(", "self", ")", ":", "result", "=", "[", "(", "'X-Powered-By'", ",", "'Zope (www.zope.org), Python (www.python.org)'", ")", "]", "encode", "=", "header_encoding_registry", ".", "encode", "for", "key", ",", "value", "in", "self", ".", "headers", ".", "items", "(", ")", ":", "if", "key", ".", "lower", "(", ")", "==", "key", ":", "# only change non-literal header names", "key", "=", "'-'", ".", "join", "(", "[", "x", ".", "capitalize", "(", ")", "for", "x", "in", "key", ".", "split", "(", "'-'", ")", "]", ")", "result", ".", "append", "(", "(", "key", ",", "encode", "(", "key", ",", "value", ")", ")", ")", "result", ".", "extend", "(", "self", ".", "_cookie_list", "(", ")", ")", "for", "key", ",", "value", "in", "self", ".", "accumulated_headers", ":", "result", ".", "append", "(", "(", "key", ",", "encode", "(", "key", ",", "value", ")", ")", ")", "return", "result" ]

[ "Set", "headers", "required", "by", "various", "parts", "of", "protocol", "." ]

[ "def", "finalize", "(", "self", ")", ":", "body", "=", "self", ".", "body", "if", "'content-length'", "not", "in", "self", ".", "headers", "and", "'transfer-encoding'", "not", "in", "self", ".", "headers", ":", "self", ".", "setHeader", "(", "'content-length'", ",", "len", "(", "body", ")", ")", "return", "\"%d %s\"", "%", "(", "self", ".", "status", ",", "self", ".", "errmsg", ")", ",", "self", ".", "listHeaders", "(", ")" ]

[ "Return", "data", "as", "a", "stream" ]

[ "def", "write", "(", "self", ",", "data", ")", ":", "if", "not", "self", ".", "_wrote", ":", "notify", "(", "pubevents", ".", "PubBeforeStreaming", "(", "self", ")", ")", "self", ".", "outputBody", "(", ")", "self", ".", "_wrote", "=", "1", "self", ".", "stdout", ".", "flush", "(", ")", "self", ".", "stdout", ".", "write", "(", "data", ")" ]

[ "Add", "data", "to", "our", "output", "stream", "." ]

[ "def", "write", "(", "self", ",", "data", ")", ":", "if", "not", "self", ".", "_streaming", ":", "notify", "(", "pubevents", ".", "PubBeforeStreaming", "(", "self", ")", ")", "self", ".", "_streaming", "=", "1", "self", ".", "stdout", ".", "flush", "(", ")", "self", ".", "stdout", ".", "write", "(", "data", ")" ]

[ "register", "*", "encoder", "*", "as", "encoder", "for", "header", "*", "header", "*", "." ]

[ "def", "register", "(", "self", ",", "header", ",", "encoder", ",", "*", "*", "kw", ")", ":", "if", "header", "is", "not", "None", ":", "header", "=", "header", ".", "lower", "(", ")", "self", "[", "header", "]", "=", "encoder", ",", "kw" ]

[ "remove", "any", "registration", "for", "*", "header", "*", "." ]

[ "def", "unregister", "(", "self", ",", "header", ")", ":", "if", "header", "is", "not", "None", ":", "header", "=", "header", ".", "lower", "(", ")", "if", "header", "in", "self", ":", "del", "self", "[", "header", "]" ]

[ "encode", "*", "value", "*", "as", "specified", "for", "*", "header", "*", "." ]

[ "def", "encode", "(", "self", ",", "header", ",", "value", ")", ":", "if", "not", "isinstance", "(", "value", ",", "str", ")", ":", "return", "value", "header", "=", "header", ".", "lower", "(", ")", "reg", "=", "self", ".", "get", "(", "header", ")", "or", "self", ".", "get", "(", "None", ")", "if", "reg", "is", "None", "or", "reg", "[", "0", "]", "is", "None", "or", "non_latin_1", "(", "value", ")", "is", "None", ":", "return", "value", "return", "reg", "[", "0", "]", "(", "value", ",", "*", "*", "reg", "[", "1", "]", ")" ]

[ "Parse", "input", "data", "and", "return", "a", "method", "path", "and", "argument", "tuple" ]

[ "def", "parse_input", "(", "data", ")", ":", "#", "# For example, with the input:", "#", "# <?xml version=\"1.0\"?>", "# <methodCall>", "# <methodName>examples.getStateName</methodName>", "# <params>", "# <param>", "# <value><i4>41</i4></value>", "# </param>", "# </params>", "# </methodCall>", "#", "# the function should return:", "#", "# ('examples.getStateName', (41,))", "params", ",", "method", "=", "xmlrpc", ".", "client", ".", "loads", "(", "data", ")", "# Translate '.' to '/' in meth to represent object traversal.", "method", "=", "method", ".", "replace", "(", "'.'", ",", "'/'", ")", "return", "method", ",", "params" ]

[ "The", "constructor", "is", "not", "allowed", "to", "raise", "errors" ]

[ "def", "__init__", "(", "self", ",", "other", "=", "None", ",", "*", "*", "kw", ")", ":", "self", ".", "__doc__", "=", "None", "# Make BaseRequest objects unpublishable", "if", "other", "is", "None", ":", "other", "=", "kw", "else", ":", "other", ".", "update", "(", "kw", ")", "self", ".", "other", "=", "other" ]

[ "Do", "any", "input", "processing", "that", "could", "raise", "errors" ]

[ "def", "processInputs", "(", "self", ")", ":" ]

[ "Set", "application", "variables" ]

[ "def", "__setitem__", "(", "self", ",", "key", ",", "value", ")", ":", "self", ".", "other", "[", "key", "]", "=", "value" ]

[ "Get", "a", "variable", "value" ]

[ "def", "get", "(", "self", ",", "key", ",", "default", "=", "None", ")", ":", "if", "key", "==", "'REQUEST'", ":", "return", "self", "v", "=", "self", ".", "other", ".", "get", "(", "key", ",", "_marker", ")", "if", "v", "is", "not", "_marker", ":", "return", "v", "v", "=", "self", ".", "common", ".", "get", "(", "key", ",", "default", ")", "if", "v", "is", "not", "_marker", ":", "return", "v", "if", "key", "==", "'BODY'", "and", "self", ".", "_file", "is", "not", "None", ":", "p", "=", "self", ".", "_file", ".", "tell", "(", ")", "self", ".", "_file", ".", "seek", "(", "0", ")", "v", "=", "self", ".", "_file", ".", "read", "(", ")", "self", ".", "_file", ".", "seek", "(", "p", ")", "self", ".", "other", "[", "key", "]", "=", "v", "return", "v", "if", "key", "==", "'BODYFILE'", "and", "self", ".", "_file", "is", "not", "None", ":", "v", "=", "self", ".", "_file", "self", ".", "other", "[", "key", "]", "=", "v", "return", "v", "return", "default" ]

[ "Traverse", "the", "object", "space" ]

[ "def", "traverse", "(", "self", ",", "path", ",", "response", "=", "None", ",", "validated_hook", "=", "None", ")", ":", "request", "=", "self", "request_get", "=", "request", ".", "get", "if", "response", "is", "None", ":", "response", "=", "self", ".", "response", "# remember path for later use", "browser_path", "=", "path", "# Cleanup the path list", "if", "path", "[", ":", "1", "]", "==", "'/'", ":", "path", "=", "path", "[", "1", ":", "]", "if", "path", "[", "-", "1", ":", "]", "==", "'/'", ":", "path", "=", "path", "[", ":", "-", "1", "]", "clean", "=", "[", "]", "for", "item", "in", "path", ".", "split", "(", "'/'", ")", ":", "# Make sure that certain things that dont make sense", "# cannot be traversed.", "if", "item", "in", "(", "'REQUEST'", ",", "'aq_self'", ",", "'aq_base'", ")", ":", "return", "response", ".", "notFoundError", "(", "path", ")", "if", "not", "item", "or", "item", "==", "'.'", ":", "continue", "elif", "item", "==", "'..'", ":", "del", "clean", "[", "-", "1", "]", "else", ":", "clean", ".", "append", "(", "item", ")", "path", "=", "clean", "# How did this request come in? (HTTP GET, PUT, POST, etc.)", "method", "=", "request_get", "(", "'REQUEST_METHOD'", ",", "'GET'", ")", ".", "upper", "(", ")", "# Probably a browser", "no_acquire_flag", "=", "0", "if", "method", "in", "(", "'GET'", ",", "'POST'", ",", "'PURGE'", ")", "and", "not", "is_xmlrpc_response", "(", "response", ")", ":", "# index_html is still the default method, only any object can", "# override it by implementing its own __browser_default__ method", "method", "=", "'index_html'", "elif", "method", "!=", "'HEAD'", "and", "self", ".", "maybe_webdav_client", ":", "# Probably a WebDAV client.", "no_acquire_flag", "=", "1", "URL", "=", "request", "[", "'URL'", "]", "parents", "=", "request", "[", "'PARENTS'", "]", "object", "=", "parents", "[", "-", "1", "]", "del", "parents", "[", ":", "]", "self", ".", "roles", "=", "getRoles", "(", "None", ",", "None", ",", "object", ",", "UNSPECIFIED_ROLES", ")", "# if the top object has a __bobo_traverse__ method, then use it", "# to possibly traverse to an alternate top-level object.", "if", "hasattr", "(", "object", ",", "'__bobo_traverse__'", ")", ":", "try", ":", "new_object", "=", "object", ".", "__bobo_traverse__", "(", "request", ")", "if", "new_object", "is", "not", "None", ":", "object", "=", "new_object", "self", ".", "roles", "=", "getRoles", "(", "None", ",", "None", ",", "object", ",", "UNSPECIFIED_ROLES", ")", "except", "Exception", ":", "pass", "if", "not", "path", "and", "not", "method", ":", "return", "response", ".", "forbiddenError", "(", "self", "[", "'URL'", "]", ")", "# Traverse the URL to find the object:", "if", "hasattr", "(", "object", ",", "'__of__'", ")", ":", "# Try to bind the top-level object to the request", "# This is how you get 'self.REQUEST'", "object", "=", "object", ".", "__of__", "(", "RequestContainer", "(", "REQUEST", "=", "request", ")", ")", "parents", ".", "append", "(", "object", ")", "steps", "=", "self", ".", "steps", "self", ".", "_steps", "=", "_steps", "=", "list", "(", "map", "(", "quote", ",", "steps", ")", ")", "path", ".", "reverse", "(", ")", "request", "[", "'TraversalRequestNameStack'", "]", "=", "request", ".", "path", "=", "path", "request", "[", "'ACTUAL_URL'", "]", "=", "request", "[", "'URL'", "]", "+", "quote", "(", "browser_path", ")", "# Set the posttraverse for duration of the traversal here", "self", ".", "_post_traverse", "=", "post_traverse", "=", "[", "]", "entry_name", "=", "''", "try", ":", "# We build parents in the wrong order, so we", "# need to make sure we reverse it when we're done.", "while", "1", ":", "bpth", "=", "getattr", "(", "object", ",", "'__before_publishing_traverse__'", ",", "None", ")", "if", "bpth", "is", "not", "None", ":", "bpth", "(", "object", ",", "self", ")", "path", "=", "request", ".", "path", "=", "request", "[", "'TraversalRequestNameStack'", "]", "# Check for method:", "if", "path", ":", "entry_name", "=", "path", ".", "pop", "(", ")", "else", ":", "# If we have reached the end of the path, we look to see", "# if we can find IBrowserPublisher.browserDefault. If so,", "# we call it to let the object tell us how to publish it.", "# BrowserDefault returns the object to be published", "# (usually self) and a sequence of names to traverse to", "# find the method to be published.", "# This is webdav support. The last object in the path", "# should not be acquired. Instead, a NullResource should", "# be given if it doesn't exist:", "if", "no_acquire_flag", "and", "hasattr", "(", "object", ",", "'aq_base'", ")", "and", "not", "hasattr", "(", "object", ",", "'__bobo_traverse__'", ")", ":", "if", "(", "object", ".", "__parent__", "is", "not", "aq_inner", "(", "object", ")", ".", "__parent__", ")", ":", "from", "webdav", ".", "NullResource", "import", "NullResource", "object", "=", "NullResource", "(", "parents", "[", "-", "2", "]", ",", "object", ".", "getId", "(", ")", ",", "self", ")", ".", "__of__", "(", "parents", "[", "-", "2", "]", ")", "if", "IBrowserPublisher", ".", "providedBy", "(", "object", ")", ":", "adapter", "=", "object", "else", ":", "adapter", "=", "queryMultiAdapter", "(", "(", "object", ",", "self", ")", ",", "IBrowserPublisher", ")", "if", "adapter", "is", "None", ":", "# Zope2 doesn't set up its own adapters in a lot", "# of cases so we will just use a default adapter.", "adapter", "=", "DefaultPublishTraverse", "(", "object", ",", "self", ")", "object", ",", "default_path", "=", "adapter", ".", "browserDefault", "(", "self", ")", "if", "default_path", ":", "request", ".", "_hacked_path", "=", "1", "if", "len", "(", "default_path", ")", ">", "1", ":", "path", "=", "list", "(", "default_path", ")", "method", "=", "path", ".", "pop", "(", ")", "request", "[", "'TraversalRequestNameStack'", "]", "=", "path", "continue", "else", ":", "entry_name", "=", "default_path", "[", "0", "]", "elif", "(", "method", "and", "hasattr", "(", "object", ",", "method", ")", "and", "entry_name", "!=", "method", "and", "getattr", "(", "object", ",", "method", ")", "is", "not", "None", ")", ":", "request", ".", "_hacked_path", "=", "1", "entry_name", "=", "method", "method", "=", "'index_html'", "else", ":", "if", "hasattr", "(", "object", ",", "'__call__'", ")", ":", "self", ".", "roles", "=", "getRoles", "(", "object", ",", "'__call__'", ",", "object", ".", "__call__", ",", "self", ".", "roles", ")", "if", "request", ".", "_hacked_path", ":", "i", "=", "URL", ".", "rfind", "(", "'/'", ")", "if", "i", ">", "0", ":", "response", ".", "setBase", "(", "URL", "[", ":", "i", "]", ")", "break", "step", "=", "quote", "(", "entry_name", ")", "_steps", ".", "append", "(", "step", ")", "request", "[", "'URL'", "]", "=", "URL", "=", "f'{request[\"URL\"]}/{step}'", "try", ":", "subobject", "=", "self", ".", "traverseName", "(", "object", ",", "entry_name", ")", "if", "hasattr", "(", "object", ",", "'__bobo_traverse__'", ")", "or", "hasattr", "(", "object", ",", "entry_name", ")", ":", "check_name", "=", "entry_name", "else", ":", "check_name", "=", "None", "self", ".", "roles", "=", "getRoles", "(", "object", ",", "check_name", ",", "subobject", ",", "self", ".", "roles", ")", "object", "=", "subobject", "# traverseName() might raise ZTK's NotFound", "except", "(", "KeyError", ",", "AttributeError", ",", "ztkNotFound", ")", ":", "if", "response", ".", "debug_mode", ":", "return", "response", ".", "debugError", "(", "\"Cannot locate object at: %s\"", "%", "URL", ")", "else", ":", "return", "response", ".", "notFoundError", "(", "URL", ")", "except", "Forbidden", "as", "e", ":", "if", "self", ".", "response", ".", "debug_mode", ":", "return", "response", ".", "debugError", "(", "e", ".", "args", ")", "else", ":", "return", "response", ".", "forbiddenError", "(", "entry_name", ")", "parents", ".", "append", "(", "object", ")", "steps", ".", "append", "(", "entry_name", ")", "finally", ":", "parents", ".", "reverse", "(", ")", "# Note - no_acquire_flag is necessary to support", "# things like DAV. We have to make sure", "# that the target object is not acquired", "# if the request_method is other than GET", "# or POST. Otherwise, you could never use", "# PUT to add a new object named 'test' if", "# an object 'test' existed above it in the", "# hierarchy -- you'd always get the", "# existing object :(", "if", "no_acquire_flag", "and", "hasattr", "(", "parents", "[", "1", "]", ",", "'aq_base'", ")", "and", "not", "hasattr", "(", "parents", "[", "1", "]", ",", "'__bobo_traverse__'", ")", ":", "base", "=", "aq_base", "(", "parents", "[", "1", "]", ")", "if", "not", "hasattr", "(", "base", ",", "entry_name", ")", ":", "try", ":", "if", "entry_name", "not", "in", "base", ":", "raise", "AttributeError", "(", "entry_name", ")", "except", "TypeError", ":", "raise", "AttributeError", "(", "entry_name", ")", "# After traversal post traversal hooks aren't available anymore", "del", "self", ".", "_post_traverse", "request", "[", "'PUBLISHED'", "]", "=", "parents", ".", "pop", "(", "0", ")", "# Do authorization checks", "user", "=", "groups", "=", "None", "i", "=", "0", "if", "1", ":", "# Always perform authentication.", "last_parent_index", "=", "len", "(", "parents", ")", "if", "hasattr", "(", "object", ",", "'__allow_groups__'", ")", ":", "groups", "=", "object", ".", "__allow_groups__", "inext", "=", "0", "else", ":", "inext", "=", "None", "for", "i", "in", "range", "(", "last_parent_index", ")", ":", "if", "hasattr", "(", "parents", "[", "i", "]", ",", "'__allow_groups__'", ")", ":", "groups", "=", "parents", "[", "i", "]", ".", "__allow_groups__", "inext", "=", "i", "+", "1", "break", "if", "inext", "is", "not", "None", ":", "i", "=", "inext", "v", "=", "getattr", "(", "groups", ",", "'validate'", ",", "old_validation", ")", "auth", "=", "request", ".", "_auth", "if", "v", "is", "old_validation", "and", "self", ".", "roles", "is", "UNSPECIFIED_ROLES", ":", "# No roles, so if we have a named group, get roles from", "# group keys", "if", "hasattr", "(", "groups", ",", "'keys'", ")", ":", "self", ".", "roles", "=", "list", "(", "groups", ".", "keys", "(", ")", ")", "else", ":", "try", ":", "groups", "=", "groups", "(", ")", "except", "Exception", ":", "pass", "try", ":", "self", ".", "roles", "=", "list", "(", "groups", ".", "keys", "(", ")", ")", "except", "Exception", ":", "pass", "if", "groups", "is", "None", ":", "# Public group, hack structures to get it to validate", "self", ".", "roles", "=", "None", "auth", "=", "''", "if", "v", "is", "old_validation", ":", "user", "=", "old_validation", "(", "groups", ",", "request", ",", "auth", ",", "self", ".", "roles", ")", "elif", "self", ".", "roles", "is", "UNSPECIFIED_ROLES", ":", "user", "=", "v", "(", "request", ",", "auth", ")", "else", ":", "user", "=", "v", "(", "request", ",", "auth", ",", "self", ".", "roles", ")", "while", "user", "is", "None", "and", "i", "<", "last_parent_index", ":", "parent", "=", "parents", "[", "i", "]", "i", "=", "i", "+", "1", "if", "hasattr", "(", "parent", ",", "'__allow_groups__'", ")", ":", "groups", "=", "parent", ".", "__allow_groups__", "else", ":", "continue", "if", "hasattr", "(", "groups", ",", "'validate'", ")", ":", "v", "=", "groups", ".", "validate", "else", ":", "v", "=", "old_validation", "if", "v", "is", "old_validation", ":", "user", "=", "old_validation", "(", "groups", ",", "request", ",", "auth", ",", "self", ".", "roles", ")", "elif", "self", ".", "roles", "is", "UNSPECIFIED_ROLES", ":", "user", "=", "v", "(", "request", ",", "auth", ")", "else", ":", "user", "=", "v", "(", "request", ",", "auth", ",", "self", ".", "roles", ")", "if", "user", "is", "None", "and", "self", ".", "roles", "!=", "UNSPECIFIED_ROLES", ":", "response", ".", "unauthorized", "(", ")", "if", "user", "is", "not", "None", ":", "if", "validated_hook", "is", "not", "None", ":", "validated_hook", "(", "self", ",", "user", ")", "request", "[", "'AUTHENTICATED_USER'", "]", "=", "user", "request", "[", "'AUTHENTICATION_PATH'", "]", "=", "'/'", ".", "join", "(", "steps", "[", ":", "-", "i", "]", ")", "# Remove http request method from the URL.", "request", "[", "'URL'", "]", "=", "URL", "# Run post traversal hooks", "if", "post_traverse", ":", "result", "=", "exec_callables", "(", "post_traverse", ")", "if", "result", "is", "not", "None", ":", "object", "=", "result", "return", "object" ]

[ "Add", "a", "callable", "object", "and", "argument", "tuple", "to", "be", "post", "-", "traversed", "." ]

[ "def", "post_traverse", "(", "self", ",", "f", ",", "args", "=", "(", ")", ")", ":", "try", ":", "pairs", "=", "self", ".", "_post_traverse", "except", "AttributeError", ":", "raise", "RuntimeError", "(", "'post_traverse() may only be called '", "'during publishing traversal.'", ")", "else", ":", "pairs", ".", "append", "(", "(", "f", ",", "tuple", "(", "args", ")", ")", ")" ]

[ "Hold", "a", "reference", "to", "an", "object", "to", "delay", "it", "s", "destruction", "until", "mine" ]

[ "def", "_hold", "(", "self", ",", "object", ")", ":", "if", "self", ".", "_held", "is", "not", "None", ":", "self", ".", "_held", "=", "self", ".", "_held", "+", "(", "object", ",", ")" ]

[ "Fix", "properties", "on", "object", "." ]

[ "def", "fix_properties", "(", "obj", ",", "path", "=", "None", ")", ":", "if", "path", "is", "None", ":", "# When using ZopeFindAndApply, path is always given.", "# But we may be called by other code.", "if", "hasattr", "(", "object", ",", "'getPhysicalPath'", ")", ":", "path", "=", "'/'", ".", "join", "(", "object", ".", "getPhysicalPath", "(", ")", ")", "else", ":", "# Some simple object, for example in tests.", "# We don't care about the path then, it is only shown in logs.", "path", "=", "\"/dummy\"", "try", ":", "prop_map", "=", "obj", ".", "propertyMap", "(", ")", "except", "AttributeError", ":", "# Object does not inherit from PropertyManager.", "# For example 'MountedObject'.", "return", "for", "prop_info", "in", "prop_map", ":", "# Example: {'id': 'title', 'type': 'string', 'mode': 'w'}", "prop_id", "=", "prop_info", ".", "get", "(", "\"id\"", ")", "current", "=", "obj", ".", "getProperty", "(", "prop_id", ")", "if", "current", "is", "None", ":", "continue", "new_type", "=", "prop_type", "=", "prop_info", ".", "get", "(", "\"type\"", ")", "if", "prop_type", "==", "\"lines\"", ":", "new", "=", "_string_tuple", "(", "current", ")", "elif", "prop_type", "==", "\"ulines\"", ":", "new_type", "=", "\"lines\"", "new", "=", "_string_tuple", "(", "current", ")", "elif", "prop_type", "==", "\"utokens\"", ":", "new_type", "=", "\"tokens\"", "new", "=", "_string_tuple", "(", "current", ")", "elif", "prop_type", "==", "\"utext\"", ":", "new_type", "=", "\"text\"", "new", "=", "safe_unicode", "(", "current", ")", "elif", "prop_type", "==", "\"ustring\"", ":", "new_type", "=", "\"string\"", "new", "=", "safe_unicode", "(", "current", ")", "else", ":", "continue", "if", "prop_type", "!=", "new_type", ":", "# Replace with non-unicode variant.", "# This could easily lead to:", "# Exceptions.BadRequest: Invalid or duplicate property id.", "# obj._delProperty(prop_id)", "# obj._setProperty(prop_id, new, new_type)", "# So fix it by using internal details.", "for", "prop", "in", "obj", ".", "_properties", ":", "if", "prop", ".", "get", "(", "\"id\"", ")", "==", "prop_id", ":", "prop", "[", "\"type\"", "]", "=", "new_type", "obj", ".", "_p_changed", "=", "True", "break", "else", ":", "# This probably cannot happen.", "# If it does, we want to know.", "logger", ".", "warning", "(", "\"Could not change property %s from %s to %s for %s\"", ",", "prop_id", ",", "prop_type", ",", "new_type", ",", "path", ",", ")", "continue", "obj", ".", "_updateProperty", "(", "prop_id", ",", "new", ")", "logger", ".", "info", "(", "\"Changed property %s from %s to %s for %s\"", ",", "prop_id", ",", "prop_type", ",", "new_type", ",", "path", ",", ")", "continue", "if", "current", "!=", "new", ":", "obj", ".", "_updateProperty", "(", "prop_id", ",", "new", ")", "logger", ".", "info", "(", "\"Changed property %s at %s so value fits the type %s: %r\"", ",", "prop_id", ",", "path", ",", "prop_type", ",", "new", ",", ")" ]

[ "Output", "the", "response", "body", "." ]

[ "def", "outputBody", "(", "self", ")", ":", "self", ".", "stdout", ".", "write", "(", "bytes", "(", "self", ")", ")" ]

[ "Returns", "the", "current", "HTTP", "status", "code", "as", "an", "integer", "." ]

[ "def", "getStatus", "(", "self", ")", ":", "return", "self", ".", "status" ]

[ "Set", "an", "HTTP", "cookie", "on", "the", "browser", "." ]

[ "def", "setCookie", "(", "self", ",", "name", ",", "value", ",", "*", "*", "kw", ")", ":", "cookies", "=", "self", ".", "cookies", "if", "name", "in", "cookies", ":", "cookie", "=", "cookies", "[", "name", "]", "else", ":", "cookie", "=", "cookies", "[", "name", "]", "=", "{", "}", "for", "k", ",", "v", "in", "kw", ".", "items", "(", ")", ":", "cookie", "[", "k", "]", "=", "v", "cookie", "[", "'value'", "]", "=", "value" ]

[ "Get", "a", "header", "value", "." ]

[ "def", "getHeader", "(", "self", ",", "name", ")", ":", "return", "self", ".", "headers", ".", "get", "(", "name", ",", "None", ")" ]

[ "Get", "the", "value", "of", "an", "output", "header", "." ]

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

[ "Returns", "bytes", "representing", "the", "currently", "set", "body", "." ]

[ "def", "getBody", "(", "self", ")", ":", "return", "self", ".", "body" ]

[ "Return", "data", "as", "a", "stream", "." ]

[ "def", "write", "(", "self", ",", "data", ")", ":", "if", "isinstance", "(", "data", ",", "str", ")", ":", "raise", "ValueError", "(", "'Data must be binary.'", ")", "self", ".", "body", "=", "self", ".", "body", "+", "data" ]

[ "Handle", "an", "exception", "." ]

[ "def", "exception", "(", "self", ",", "fatal", "=", "0", ",", "info", "=", "None", ")", ":" ]

[ "Generate", "an", "error", "indicating", "that", "an", "object", "was", "not", "found", "." ]

[ "def", "notFoundError", "(", "self", ",", "v", "=", "''", ")", ":", "raise", "NotFound", "(", "v", ")" ]

[ "Raise", "an", "error", "with", "debugging", "info", "and", "in", "debugging", "mode", "." ]

[ "def", "debugError", "(", "self", ",", "v", "=", "''", ")", ":", "raise", "NotFound", "(", "\"Debugging notice: %s\"", "%", "v", ")" ]

[ "Raise", "an", "error", "indicating", "something", "wrong", "with", "the", "request", "." ]

[ "def", "badRequestError", "(", "self", ",", "v", "=", "''", ")", ":", "raise", "BadRequest", "(", "v", ")" ]

[ "Raise", "an", "error", "indicating", "that", "the", "request", "cannot", "be", "done", "." ]

[ "def", "forbiddenError", "(", "self", ",", "v", "=", "''", ")", ":", "raise", "Forbidden", "(", "v", ")" ]

[ "Raise", "an", "error", "indicating", "that", "the", "user", "was", "not", "authorized", "." ]

[ "def", "unauthorized", "(", "self", ")", ":", "raise", "Unauthorized", "(", ")" ]

[ "Converts", "value", "to", "string", "." ]

[ "def", "field2string", "(", "v", ")", ":", "if", "isinstance", "(", "v", ",", "bytes", ")", ":", "return", "v", ".", "decode", "(", "default_encoding", ")", "else", ":", "return", "str", "(", "v", ")" ]

[ "Converts", "value", "to", "bytes", "." ]

[ "def", "field2bytes", "(", "v", ")", ":", "if", "hasattr", "(", "v", ",", "'read'", ")", ":", "return", "v", ".", "read", "(", ")", "elif", "isinstance", "(", "v", ",", "str", ")", ":", "return", "v", ".", "encode", "(", "default_encoding", ")", "else", ":", "return", "bytes", "(", "v", ")" ]

[ "Return", "a", "sequence", "of", "bytes", "out", "of", "the", "bytestream", "or", "raise", "StopIeration", "if", "we", "ve", "reached", "the", "end", "of", "the", "bytestream", "." ]

[ "def", "__next__", "(", ")", ":" ]

[ "Return", "an", "integer", "representing", "the", "length", "of", "the", "object", "in", "bytes", "." ]

[ "def", "__len__", "(", ")", ":" ]

[ "Perform", "a", "full", "sweep", "through", "the", "cache" ]

[ "def", "manage_minimize", "(", "self", ",", "value", "=", "1", ",", "REQUEST", "=", "None", ")", ":", "# XXX Add a deprecation warning about value?", "self", ".", "_getDB", "(", ")", ".", "cacheMinimize", "(", ")", "if", "REQUEST", "is", "not", "None", ":", "msg", "=", "'ZODB in-memory caches minimized.'", "url", "=", "f'{REQUEST[\"URL1\"]}/manage_main?manage_tabs_message={msg}'", "REQUEST", ".", "RESPONSE", ".", "redirect", "(", "url", ")" ]

[ "Pack", "the", "database" ]

[ "def", "manage_pack", "(", "self", ",", "days", "=", "0", ",", "REQUEST", "=", "None", ")", ":", "if", "not", "isinstance", "(", "days", ",", "(", "int", ",", "float", ")", ")", ":", "try", ":", "days", "=", "float", "(", "days", ")", "except", "ValueError", ":", "days", "=", "None", "if", "days", "is", "not", "None", ":", "t", "=", "time", ".", "time", "(", ")", "-", "(", "days", "*", "86400", ")", "self", ".", "_getDB", "(", ")", ".", "pack", "(", "t", ")", "msg", "=", "'Database packed to %s days'", "%", "str", "(", "days", ")", "else", ":", "t", "=", "None", "msg", "=", "'Invalid days value %s'", "%", "str", "(", "days", ")", "if", "REQUEST", "is", "not", "None", ":", "url", "=", "f'{REQUEST[\"URL1\"]}/manage_main?manage_tabs_message={msg}'", "REQUEST", "[", "'RESPONSE'", "]", ".", "redirect", "(", "url", ")", "return", "t" ]

[ "Returns", "the", "name", "of", "the", "classes", "of", "the", "objects", "in", "the", "cache", "and", "the", "number", "of", "objects", "in", "the", "cache", "for", "each", "class", "." ]

[ "def", "cache_detail", "(", "self", ",", "REQUEST", "=", "None", ")", ":", "detail", "=", "self", ".", "_getDB", "(", ")", ".", "cacheDetail", "(", ")", "if", "REQUEST", "is", "not", "None", ":", "# format as text", "REQUEST", ".", "RESPONSE", ".", "setHeader", "(", "'Content-Type'", ",", "'text/plain'", ")", "return", "'\\n'", ".", "join", "(", "[", "'%6d %s'", "%", "(", "count", ",", "name", ")", "for", "name", ",", "count", "in", "detail", "]", ")", "# raw", "return", "detail" ]

[ "Returns", "information", "about", "each", "object", "in", "the", "cache", "." ]

[ "def", "cache_extreme_detail", "(", "self", ",", "REQUEST", "=", "None", ")", ":", "detail", "=", "self", ".", "_getDB", "(", ")", ".", "cacheExtremeDetail", "(", ")", "if", "REQUEST", "is", "not", "None", ":", "# sort the list.", "lst", "=", "[", "(", "(", "dict", "[", "'conn_no'", "]", ",", "dict", "[", "'oid'", "]", ")", ",", "dict", ")", "for", "dict", "in", "detail", "]", "# format as text.", "res", "=", "[", "'# Table shows connection number, oid, refcount, state, '", "'and class.'", ",", "'# States: L = loaded, G = ghost, C = changed'", "]", "for", "sortkey", ",", "dict", "in", "lst", ":", "id", "=", "dict", ".", "get", "(", "'id'", ",", "None", ")", "if", "id", ":", "idinfo", "=", "' (%s)'", "%", "id", "else", ":", "idinfo", "=", "''", "s", "=", "dict", "[", "'state'", "]", "if", "s", "==", "0", ":", "state", "=", "'L'", "# loaded", "elif", "s", "==", "1", ":", "state", "=", "'C'", "# changed", "else", ":", "state", "=", "'G'", "# ghost", "res", ".", "append", "(", "'%d %-34s %6d %s %s%s'", "%", "(", "dict", "[", "'conn_no'", "]", ",", "repr", "(", "dict", "[", "'oid'", "]", ")", ",", "dict", "[", "'rc'", "]", ",", "state", ",", "dict", "[", "'klass'", "]", ",", "idinfo", ")", ")", "REQUEST", ".", "RESPONSE", ".", "setHeader", "(", "'Content-Type'", ",", "'text/plain'", ")", "return", "'\\n'", ".", "join", "(", "res", ")", "else", ":", "# raw", "return", "detail" ]

[ "return", "information", "about", "the", "Zope", "version", "as", "a", "named", "tuple", "." ]

[ "def", "getZopeVersion", "(", ")", ":", "_prep_version_data", "(", ")", "return", "_zope_version" ]

[ "Logout", "current", "user" ]

[ "def", "manage_zmi_logout", "(", "REQUEST", ",", "RESPONSE", ")", ":" ]

[ "Return", "the", "global", "Zope", "configuration", "object", "." ]

[ "def", "getConfiguration", "(", ")", ":", "if", "_config", "is", "None", ":", "setConfiguration", "(", "DefaultConfiguration", "(", ")", ")", "return", "_config" ]

[ "Set", "the", "global", "configuration", "object", "." ]

[ "def", "setConfiguration", "(", "cfg", ")", ":", "global", "_config", "_config", "=", "cfg", "if", "cfg", "is", "None", ":", "return", "from", "App", "import", "FindHomes", "FindHomes", ".", "CLIENT_HOME", "=", "cfg", ".", "clienthome", "os", ".", "environ", "[", "\"CLIENT_HOME\"", "]", "=", "cfg", ".", "clienthome", "FindHomes", ".", "INSTANCE_HOME", "=", "cfg", ".", "instancehome", "os", ".", "environ", "[", "\"INSTANCE_HOME\"", "]", "=", "cfg", ".", "instancehome" ]

[ "Management", "screen", "action", "to", "unlock", "objects", "." ]

[ "def", "manage_unlockObjects", "(", "self", ",", "paths", "=", "[", "]", ",", "REQUEST", "=", "None", ")", ":", "if", "paths", ":", "self", ".", "unlockObjects", "(", "paths", ")", "if", "REQUEST", "is", "not", "None", ":", "m", "=", "'%s objects unlocked.'", "%", "len", "(", "paths", ")", "return", "self", ".", "manage_davlocks", "(", "self", ",", "REQUEST", ",", "manage_tabs_message", "=", "m", ")" ]

[ "Returns", "all", "product", "packages", "including", "the", "regularly", "defined", "zope2", "packages", "and", "those", "without", "the", "Products", "namespace", "package", "." ]

[ "def", "_product_packages", "(", ")", ":", "import", "Products", "_packages", "=", "{", "}", "for", "x", "in", "dir", "(", "Products", ")", ":", "m", "=", "getattr", "(", "Products", ",", "x", ")", "if", "isinstance", "(", "m", ",", "types", ".", "ModuleType", ")", ":", "_packages", "[", "x", "]", "=", "m", "for", "m", "in", "get_registered_packages", "(", ")", ":", "_packages", "[", "m", ".", "__name__", "]", "=", "m", "return", "_packages" ]

[ "Return", "the", "destination", "for", "factory", "output" ]

[ "def", "Destination", "(", "self", ")", ":", "return", "self" ]

[ "Return", "the", "destination", "for", "factory", "output" ]

[ "def", "Destination", "(", "self", ")", ":", "return", "self", ".", "__dict__", "[", "'_d'", "]" ]

[ "Return", "the", "URL", "for", "the", "destination", "for", "factory", "output" ]

[ "def", "DestinationURL", "(", "self", ")", ":", "url", "=", "getattr", "(", "self", ",", "'_u'", ",", "None", ")", "if", "url", "is", "None", ":", "url", "=", "self", ".", "Destination", "(", ")", ".", "absolute_url", "(", ")", "return", "url" ]

[ "Implement", "a", "contents", "view", "by", "redirecting", "to", "the", "true", "view" ]

[ "def", "manage_main", "(", "trueself", ",", "self", ",", "REQUEST", ",", "update_menu", "=", "0", ")", ":", "REQUEST", ".", "RESPONSE", ".", "redirect", "(", "self", ".", "DestinationURL", "(", ")", "+", "'/manage_main'", ")" ]

[ "Find", "a", "file", "in", "one", "of", "several", "relative", "locations" ]

[ "def", "getPath", "(", "prefix", ",", "name", ",", "checkProduct", "=", "1", ",", "suffixes", "=", "(", "''", ",", ")", ",", "cfg", "=", "None", ")", ":", "dir", ",", "ignored", "=", "os", ".", "path", ".", "split", "(", "name", ")", "if", "dir", ":", "raise", "ValueError", "(", "'The file name, %s, should be a simple file name'", "%", "name", ")", "if", "checkProduct", ":", "dot", "=", "name", ".", "find", "(", "'.'", ")", "if", "dot", ">", "0", ":", "product", "=", "name", "[", ":", "dot", "]", "extname", "=", "name", "[", "dot", "+", "1", ":", "]", "for", "product_dir", "in", "Products", ".", "__path__", ":", "found", "=", "_getPath", "(", "product_dir", ",", "os", ".", "path", ".", "join", "(", "product", ",", "prefix", ")", ",", "extname", ",", "suffixes", ")", "if", "found", "is", "not", "None", ":", "return", "found", "if", "cfg", "is", "None", ":", "import", "App", ".", "config", "cfg", "=", "App", ".", "config", ".", "getConfiguration", "(", ")", "if", "prefix", "==", "\"Extensions\"", "and", "getattr", "(", "cfg", ",", "'extensions'", ",", "None", ")", "is", "not", "None", ":", "found", "=", "_getPath", "(", "cfg", ".", "extensions", ",", "''", ",", "name", ",", "suffixes", ")", "if", "found", "is", "not", "None", ":", "return", "found", "locations", "=", "[", "cfg", ".", "instancehome", "]", "for", "home", "in", "locations", ":", "found", "=", "_getPath", "(", "home", ",", "prefix", ",", "name", ",", "suffixes", ")", "if", "found", "is", "not", "None", ":", "return", "found", "try", ":", "dot", "=", "name", ".", "rfind", "(", "'.'", ")", "if", "dot", ">", "0", ":", "realName", "=", "name", "[", "dot", "+", "1", ":", "]", "toplevel", "=", "name", "[", ":", "dot", "]", "rdot", "=", "toplevel", ".", "rfind", "(", "'.'", ")", "if", "rdot", ">", "-", "1", ":", "module", "=", "__import__", "(", "toplevel", ",", "globals", "(", ")", ",", "{", "}", ",", "toplevel", "[", "rdot", "+", "1", ":", "]", ")", "else", ":", "module", "=", "__import__", "(", "toplevel", ")", "prefix", "=", "os", ".", "path", ".", "join", "(", "module", ".", "__path__", "[", "0", "]", ",", "prefix", ",", "realName", ")", "for", "suffix", "in", "suffixes", ":", "if", "suffix", ":", "fn", "=", "f\"{prefix}.{suffix}\"", "else", ":", "fn", "=", "prefix", "if", "os", ".", "path", ".", "exists", "(", "fn", ")", ":", "return", "fn", "except", "Exception", ":", "pass" ]

[ "Dispatch", "to", "first", "interface", "in", "manage_options" ]

[ "def", "manage_workspace", "(", "self", ",", "REQUEST", ")", ":", "options", "=", "self", ".", "filtered_manage_options", "(", "REQUEST", ")", "try", ":", "m", "=", "options", "[", "0", "]", "[", "'action'", "]", "if", "m", "==", "'manage_workspace'", ":", "raise", "TypeError", "except", "(", "IndexError", ",", "KeyError", ")", ":", "raise", "Unauthorized", "(", "'You are not authorized to view this object.'", ")", "if", "m", ".", "find", "(", "'/'", ")", ":", "return", "REQUEST", ".", "RESPONSE", ".", "redirect", "(", "f\"{REQUEST['URL1']}/{m}\"", ")", "return", "getattr", "(", "self", ",", "m", ")", "(", "self", ",", "REQUEST", ")" ]

[ "Default", "document" ]

[ "def", "index_html", "(", "self", ",", "REQUEST", ",", "RESPONSE", ")", ":", "# HTTP If-Modified-Since header handling. This is duplicated", "# from OFS.Image.Image - it really should be consolidated", "# somewhere...", "RESPONSE", ".", "setHeader", "(", "'Content-Type'", ",", "self", ".", "content_type", ")", "RESPONSE", ".", "setHeader", "(", "'Last-Modified'", ",", "self", ".", "lmh", ")", "RESPONSE", ".", "setHeader", "(", "'Cache-Control'", ",", "self", ".", "cch", ")", "header", "=", "REQUEST", ".", "get_header", "(", "'If-Modified-Since'", ",", "None", ")", "if", "header", "is", "not", "None", ":", "header", "=", "header", ".", "split", "(", "';'", ")", "[", "0", "]", "# Some proxies seem to send invalid date strings for this", "# header. If the date string is not valid, we ignore it", "# rather than raise an error to be generally consistent", "# with common servers such as Apache (which can usually", "# understand the screwy date string as a lucky side effect", "# of the way they parse it).", "try", ":", "mod_since", "=", "int", "(", "DateTime", "(", "header", ")", ".", "timeTime", "(", ")", ")", "except", "Exception", ":", "mod_since", "=", "None", "if", "mod_since", "is", "not", "None", ":", "if", "getattr", "(", "self", ",", "'lmt'", ",", "None", ")", ":", "last_mod", "=", "int", "(", "self", ".", "lmt", ")", "else", ":", "last_mod", "=", "int", "(", "0", ")", "if", "last_mod", ">", "0", "and", "last_mod", "<=", "mod_since", ":", "RESPONSE", ".", "setHeader", "(", "'Content-Length'", ",", "'0'", ")", "RESPONSE", ".", "setStatus", "(", "304", ")", "return", "''", "RESPONSE", ".", "setHeader", "(", "'Content-Length'", ",", "str", "(", "self", ".", "size", ")", ".", "replace", "(", "'L'", ",", "''", ")", ")", "return", "filestream_iterator", "(", "self", ".", "path", ",", "mode", "=", "'rb'", ")" ]

[ "Register", "a", "constructor" ]

[ "def", "registerClass", "(", "self", ",", "instance_class", "=", "None", ",", "meta_type", "=", "''", ",", "permission", "=", "None", ",", "constructors", "=", "(", ")", ",", "icon", "=", "None", ",", "permissions", "=", "None", ",", "legacy", "=", "(", ")", ",", "visibility", "=", "\"Global\"", ",", "interfaces", "=", "_marker", ",", "container_filter", "=", "None", ")", ":", "pack", "=", "self", ".", "__pack", "initial", "=", "constructors", "[", "0", "]", "productObject", "=", "self", ".", "__prod", "pid", "=", "productObject", ".", "id", "if", "permissions", ":", "if", "isinstance", "(", "permissions", ",", "str", ")", ":", "# You goofed it!", "raise", "TypeError", "(", "'Product context permissions should be a '", "'list of permissions not a string'", ",", "permissions", ")", "for", "p", "in", "permissions", ":", "if", "isinstance", "(", "p", ",", "tuple", ")", ":", "p", ",", "default", "=", "p", "registerPermissions", "(", "(", "(", "p", ",", "(", ")", ",", "default", ")", ",", ")", ")", "else", ":", "registerPermissions", "(", "(", "(", "p", ",", "(", ")", ")", ",", ")", ")", "############################################################", "# Constructor permission setup", "if", "permission", "is", "None", ":", "permission", "=", "\"Add %ss\"", "%", "(", "meta_type", "or", "instance_class", ".", "meta_type", ")", "if", "isinstance", "(", "permission", ",", "tuple", ")", ":", "permission", ",", "default", "=", "permission", "else", ":", "default", "=", "(", "'Manager'", ",", ")", "pr", "=", "PermissionRole", "(", "permission", ",", "default", ")", "registerPermissions", "(", "(", "(", "permission", ",", "(", ")", ",", "default", ")", ",", ")", ")", "############################################################", "OM", "=", "ObjectManager", "for", "method", "in", "legacy", ":", "if", "isinstance", "(", "method", ",", "tuple", ")", ":", "name", ",", "method", "=", "method", "aliased", "=", "1", "else", ":", "name", "=", "method", ".", "__name__", "aliased", "=", "0", "if", "name", "not", "in", "OM", ".", "__dict__", ":", "setattr", "(", "OM", ",", "name", ",", "method", ")", "setattr", "(", "OM", ",", "name", "+", "'__roles__'", ",", "pr", ")", "if", "aliased", ":", "# Set the unaliased method name and its roles", "# to avoid security holes. XXX: All \"legacy\"", "# methods need to be eliminated.", "setattr", "(", "OM", ",", "method", ".", "__name__", ",", "method", ")", "setattr", "(", "OM", ",", "method", ".", "__name__", "+", "'__roles__'", ",", "pr", ")", "if", "isinstance", "(", "initial", ",", "tuple", ")", ":", "name", ",", "initial", "=", "initial", "else", ":", "name", "=", "initial", ".", "__name__", "fd", "=", "getattr", "(", "pack", ",", "'__FactoryDispatcher__'", ",", "None", ")", "if", "fd", "is", "None", ":", "class", "__FactoryDispatcher__", "(", "FactoryDispatcher", ")", ":", "\"Factory Dispatcher for a Specific Product\"", "fd", "=", "pack", ".", "__FactoryDispatcher__", "=", "__FactoryDispatcher__", "if", "not", "hasattr", "(", "pack", ",", "'_m'", ")", ":", "pack", ".", "_m", "=", "AttrDict", "(", "fd", ")", "m", "=", "pack", ".", "_m", "if", "interfaces", "is", "_marker", ":", "if", "instance_class", "is", "None", ":", "interfaces", "=", "(", ")", "else", ":", "interfaces", "=", "tuple", "(", "implementedBy", "(", "instance_class", ")", ")", "Products", ".", "meta_types", "=", "Products", ".", "meta_types", "+", "(", "{", "'name'", ":", "meta_type", "or", "instance_class", ".", "meta_type", ",", "# 'action': The action in the add drop down in the ZMI. This is", "# currently also required by the _verifyObjectPaste", "# method of CopyContainers like Folders.", "'action'", ":", "(", "f'manage_addProduct/{pid}/{name}'", ")", ",", "# 'product': product id", "'product'", ":", "pid", ",", "# 'permission': Guards the add action.", "'permission'", ":", "permission", ",", "# 'visibility': A silly name. Doesn't have much to do with", "# visibility. Allowed values: 'Global', None", "'visibility'", ":", "visibility", ",", "# 'interfaces': A tuple of oldstyle and/or newstyle interfaces.", "'interfaces'", ":", "interfaces", ",", "'instance'", ":", "instance_class", ",", "'container_filter'", ":", "container_filter", "}", ",", ")", "m", "[", "name", "]", "=", "initial", "m", "[", "name", "+", "'__roles__'", "]", "=", "pr", "for", "method", "in", "constructors", "[", "1", ":", "]", ":", "if", "isinstance", "(", "method", ",", "tuple", ")", ":", "name", ",", "method", "=", "method", "else", ":", "name", "=", "os", ".", "path", ".", "split", "(", "method", ".", "__name__", ")", "[", "-", "1", "]", "if", "name", "not", "in", "productObject", ".", "__dict__", ":", "m", "[", "name", "]", "=", "method", "m", "[", "name", "+", "'__roles__'", "]", "=", "pr" ]

[ "This", "method", "is", "required", "of", "all", "objects", "that", "go", "into", "the", "security", "context", "stack", "." ]

[ "def", "getOwner", "(", "self", ",", "info", "=", "0", ")", ":", "return", "None" ]

[ "Retrieve", "default", "encoding", "from", "config" ]

[ "def", "_default_encoding", "(", ")", ":", "global", "_DEFAULT_ENCODING", "if", "_DEFAULT_ENCODING", "is", "None", ":", "from", "App", ".", "config", "import", "getConfiguration", "config", "=", "getConfiguration", "(", ")", "try", ":", "_DEFAULT_ENCODING", "=", "config", ".", "zpublisher_default_encoding", "except", "AttributeError", ":", "_DEFAULT_ENCODING", "=", "'utf8'", "return", "_DEFAULT_ENCODING" ]

[ "Construct", "a", "URL", "query", "string", "with", "marshalling", "markup", "." ]

[ "def", "make_query", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "d", "=", "{", "}", "for", "arg", "in", "args", ":", "d", ".", "update", "(", "arg", ")", "d", ".", "update", "(", "kwargs", ")", "qlist", "=", "complex_marshal", "(", "list", "(", "d", ".", "items", "(", ")", ")", ")", "for", "i", "in", "range", "(", "len", "(", "qlist", ")", ")", ":", "k", ",", "m", ",", "v", "=", "qlist", "[", "i", "]", "qlist", "[", "i", "]", "=", "f'{quote(k)}{m}={quote(str(v))}'", "return", "'&'", ".", "join", "(", "qlist", ")" ]

[ "Construct", "a", "set", "of", "hidden", "input", "elements", "with", "marshalling", "markup", "." ]

[ "def", "make_hidden_input", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "d", "=", "{", "}", "for", "arg", "in", "args", ":", "d", ".", "update", "(", "arg", ")", "d", ".", "update", "(", "kwargs", ")", "def", "hq", "(", "x", ")", ":", "return", "html", ".", "escape", "(", "x", ",", "quote", "=", "True", ")", "qlist", "=", "complex_marshal", "(", "list", "(", "d", ".", "items", "(", ")", ")", ")", "for", "i", "in", "range", "(", "len", "(", "qlist", ")", ")", ":", "k", ",", "m", ",", "v", "=", "qlist", "[", "i", "]", "qlist", "[", "i", "]", "=", "(", "'<input type=\"hidden\" name=\"%s%s\" value=\"%s\">'", "%", "(", "hq", "(", "k", ")", ",", "m", ",", "hq", "(", "str", "(", "v", ")", ")", ")", ")", "return", "'\\n'", ".", "join", "(", "qlist", ")" ]

[ "Add", "request", "marshalling", "information", "to", "a", "list", "of", "name", "-", "value", "pairs", "." ]

[ "def", "complex_marshal", "(", "pairs", ")", ":", "i", "=", "len", "(", "pairs", ")", "while", "i", ">", "0", ":", "i", "=", "i", "-", "1", "k", ",", "v", "=", "pairs", "[", "i", "]", "m", "=", "''", "sublist", "=", "None", "if", "isinstance", "(", "v", ",", "str", ")", ":", "pass", "elif", "hasattr", "(", "v", ",", "'items'", ")", ":", "sublist", "=", "[", "]", "for", "sk", ",", "sv", "in", "v", ".", "items", "(", ")", ":", "if", "isinstance", "(", "sv", ",", "list", ")", ":", "for", "ssv", "in", "sv", ":", "sm", "=", "simple_marshal", "(", "ssv", ")", "sublist", ".", "append", "(", "(", "f'{k}.{sk}'", ",", "'%s:list:record'", "%", "sm", ",", "ssv", ")", ")", "else", ":", "sm", "=", "simple_marshal", "(", "sv", ")", "sublist", ".", "append", "(", "(", "f'{k}.{sk}'", ",", "'%s:record'", "%", "sm", ",", "sv", ")", ")", "elif", "isinstance", "(", "v", ",", "list", ")", ":", "sublist", "=", "[", "]", "for", "sv", "in", "v", ":", "sm", "=", "simple_marshal", "(", "sv", ")", "sublist", ".", "append", "(", "(", "k", ",", "'%s:list'", "%", "sm", ",", "sv", ")", ")", "else", ":", "m", "=", "simple_marshal", "(", "v", ")", "if", "sublist", "is", "None", ":", "pairs", "[", "i", "]", "=", "(", "k", ",", "m", ",", "v", ")", "else", ":", "pairs", "[", "i", ":", "i", "+", "1", "]", "=", "sublist", "return", "pairs" ]

[ "Construct", "a", "URL", "with", "a", "query", "string", "using", "the", "current", "request", "." ]

[ "def", "url_query", "(", "request", ",", "req_name", "=", "\"URL\"", ",", "omit", "=", "None", ")", ":", "base", "=", "request", "[", "req_name", "]", "qs", "=", "request", ".", "get", "(", "'QUERY_STRING'", ",", "''", ")", "if", "qs", "and", "omit", ":", "qsparts", "=", "qs", ".", "split", "(", "'&'", ")", "if", "isinstance", "(", "omit", ",", "str", ")", ":", "omits", "=", "{", "omit", ":", "None", "}", "else", ":", "omits", "=", "{", "}", "for", "name", "in", "omit", ":", "omits", "[", "name", "]", "=", "None", "for", "i", "in", "range", "(", "len", "(", "qsparts", ")", ")", ":", "name", "=", "unquote", "(", "qsparts", "[", "i", "]", ".", "split", "(", "'='", ",", "1", ")", "[", "0", "]", ")", "if", "name", "in", "omits", ":", "qsparts", "[", "i", "]", "=", "''", "name", "=", "name", ".", "split", "(", "':'", ",", "1", ")", "[", "0", "]", "if", "name", "in", "omits", ":", "qsparts", "[", "i", "]", "=", "''", "name", "=", "name", ".", "split", "(", "'.'", ",", "1", ")", "[", "0", "]", "if", "name", "in", "omits", ":", "qsparts", "[", "i", "]", "=", "''", "qs", "=", "'&'", ".", "join", "(", "[", "part", "for", "part", "in", "qsparts", "if", "part", "]", ")", "# We always append '?' since arguments will be appended to the URL", "return", "f'{base}?{qs}'" ]

[ "Make", "a", "tree", "with", "state", "stored", "in", "a", "cookie", "." ]

[ "def", "cookieTree", "(", "self", ",", "root_object", ",", "default_state", "=", "None", ")", ":", "tree_pre", "=", "self", ".", "tree_pre", "state_name", "=", "'%s-state'", "%", "tree_pre", "set_name", "=", "'%s-setstate'", "%", "tree_pre", "req", "=", "root_object", ".", "REQUEST", "state", "=", "req", ".", "get", "(", "state_name", ")", "if", "state", ":", "setst", "=", "req", ".", "form", ".", "get", "(", "set_name", ")", "if", "setst", ":", "st", ",", "pn", ",", "expid", "=", "setst", ".", "split", "(", "','", ")", "state", ",", "(", "m", ",", "obid", ")", "=", "decodeExpansion", "(", "state", ",", "int", "(", "pn", ")", ")", "if", "m", "is", "None", ":", "pass", "elif", "st", "==", "'e'", ":", "if", "m", "[", "obid", "]", "is", "None", ":", "m", "[", "obid", "]", "=", "{", "expid", ":", "None", "}", "else", ":", "m", "[", "obid", "]", "[", "expid", "]", "=", "None", "elif", "st", "==", "'c'", "and", "m", "is", "not", "state", "and", "obid", "==", "expid", ":", "del", "m", "[", "obid", "]", "else", ":", "state", "=", "decodeExpansion", "(", "state", ")", "else", ":", "state", "=", "default_state", "tree", "=", "self", ".", "tree", "(", "root_object", ",", "state", ")", "rows", "=", "tree", ".", "flat", "(", ")", "req", ".", "RESPONSE", ".", "setCookie", "(", "state_name", ",", "encodeExpansion", "(", "rows", ")", ")", "return", "tree", ",", "rows" ]

[ "Encapsulate", "sequence", "in", "batches", "of", "size", "." ]

[ "def", "__init__", "(", "self", ",", "sequence", ",", "size", ",", "start", "=", "0", ",", "end", "=", "0", ",", "orphan", "=", "0", ",", "overlap", "=", "0", ")", ":", "start", "=", "start", "+", "1", "start", ",", "end", ",", "sz", "=", "opt", "(", "start", ",", "end", ",", "size", ",", "orphan", ",", "sequence", ")", "self", ".", "_sequence", "=", "sequence", "self", ".", "size", "=", "sz", "self", ".", "_size", "=", "size", "self", ".", "start", "=", "start", "self", ".", "end", "=", "end", "self", ".", "orphan", "=", "orphan", "self", ".", "overlap", "=", "overlap", "self", ".", "first", "=", "max", "(", "start", "-", "1", ",", "0", ")", "self", ".", "length", "=", "self", ".", "end", "-", "self", ".", "first", "if", "self", ".", "first", "==", "0", ":", "self", ".", "previous", "=", "None" ]

[ "Encode", "a", "bytes", "/", "string", "as", "a", "cookie", "-", "and", "url", "-", "safe", "string", "." ]

[ "def", "b2a", "(", "s", ")", ":", "if", "not", "isinstance", "(", "s", ",", "bytes", ")", ":", "s", "=", "str", "(", "s", ")", "if", "isinstance", "(", "s", ",", "str", ")", ":", "s", "=", "s", ".", "encode", "(", "'utf-8'", ")", "return", "base64", ".", "urlsafe_b64encode", "(", "s", ")" ]

[ "Decode", "a", "b2a", "-", "encoded", "value", "to", "bytes", "." ]

[ "def", "a2b", "(", "s", ")", ":", "if", "not", "isinstance", "(", "s", ",", "bytes", ")", ":", "if", "isinstance", "(", "s", ",", "str", ")", ":", "s", "=", "s", ".", "encode", "(", "'ascii'", ")", "return", "base64", ".", "urlsafe_b64decode", "(", "s", ")" ]

[ "Encode", "the", "expanded", "node", "ids", "of", "a", "tree", "into", "bytes", "." ]

[ "def", "encodeExpansion", "(", "nodes", ",", "compress", "=", "1", ")", ":", "steps", "=", "[", "]", "last_depth", "=", "-", "1", "for", "n", ",", "node", "in", "enumerate", "(", "nodes", ")", ":", "if", "node", ".", "state", "<=", "0", ":", "continue", "dd", "=", "last_depth", "-", "node", ".", "depth", "+", "1", "last_depth", "=", "node", ".", "depth", "if", "dd", ">", "0", ":", "steps", ".", "append", "(", "'_'", "*", "dd", ")", "steps", ".", "append", "(", "node", ".", "id", ")", "# id is bytes", "node", ".", "expansion_number", "=", "n", "result", "=", "b':'", ".", "join", "(", "steps", ")", "if", "compress", "and", "len", "(", "result", ")", ">", "2", ":", "zresult", "=", "b':'", "+", "b2a", "(", "zlib", ".", "compress", "(", "result", ",", "9", ")", ")", "if", "len", "(", "zresult", ")", "<", "len", "(", "result", ")", ":", "result", "=", "zresult", "return", "result" ]

[ "Decode", "an", "expanded", "node", "map", "from", "bytes", "." ]

[ "def", "decodeExpansion", "(", "s", ",", "nth", "=", "None", ",", "maxsize", "=", "8192", ")", ":", "if", "len", "(", "s", ")", ">", "maxsize", ":", "# Set limit to avoid DoS attacks.", "raise", "ValueError", "(", "'Encoded node map too large'", ")", "if", "s", ".", "startswith", "(", "b':'", ")", ":", "# Compressed state", "dec", "=", "zlib", ".", "decompressobj", "(", ")", "s", "=", "dec", ".", "decompress", "(", "a2b", "(", "s", "[", "1", ":", "]", ")", ",", "maxsize", ")", "if", "dec", ".", "unconsumed_tail", ":", "raise", "ValueError", "(", "'Encoded node map too large'", ")", "del", "dec", "map", "=", "m", "=", "{", "}", "mstack", "=", "[", "]", "pop", "=", "0", "nth_pair", "=", "None", "if", "nth", "is", "not", "None", ":", "nth_pair", "=", "(", "None", ",", "None", ")", "obid", "=", "None", "for", "step", "in", "s", ".", "split", "(", "b':'", ")", ":", "if", "step", ".", "startswith", "(", "b'_'", ")", ":", "pop", "=", "len", "(", "step", ")", "-", "1", "continue", "if", "pop", "<", "0", ":", "mstack", ".", "append", "(", "m", ")", "m", "[", "obid", "]", "=", "{", "}", "m", "=", "m", "[", "obid", "]", "elif", "map", ":", "m", "[", "obid", "]", "=", "None", "if", "len", "(", "step", ")", "==", "0", ":", "return", "map", "obid", "=", "step", "if", "pop", ">", "0", ":", "m", "=", "mstack", "[", "-", "pop", "]", "del", "mstack", "[", "-", "pop", ":", "]", "pop", "=", "-", "1", "if", "nth", "==", "0", ":", "nth_pair", "=", "(", "m", ",", "obid", ")", "nth", "=", "None", "elif", "nth", "is", "not", "None", ":", "nth", "=", "nth", "-", "1", "m", "[", "obid", "]", "=", "None", "if", "nth", "==", "0", ":", "return", "map", ",", "(", "m", ",", "obid", ")", "if", "nth_pair", "is", "not", "None", ":", "return", "map", ",", "nth_pair", "return", "map" ]

[ "Add", "a", "child", "which", "already", "has", "all", "of", "its", "children", "." ]

[ "def", "_add_child", "(", "self", ",", "child", ")", ":", "self", ".", "_child_list", ".", "append", "(", "child", ")", "self", ".", "height", "=", "max", "(", "self", ".", "height", ",", "child", ".", "height", "+", "1", ")", "self", ".", "size", "=", "self", ".", "size", "+", "child", ".", "size" ]

[ "Return", "a", "flattened", "preorder", "list", "of", "tree", "nodes" ]

[ "def", "flat", "(", "self", ")", ":", "items", "=", "[", "]", "self", ".", "walk", "(", "items", ".", "append", ")", "return", "items" ]

[ "Preorder", "walk", "this", "tree", "passing", "each", "node", "to", "a", "function" ]

[ "def", "walk", "(", "self", ",", "f", ",", "data", "=", "None", ")", ":", "if", "data", "is", "None", ":", "f", "(", "self", ")", "else", ":", "f", "(", "self", ",", "data", ")", "for", "child", "in", "self", ".", "_child_list", ":", "child", ".", "__of__", "(", "self", ")", ".", "walk", "(", "f", ",", "data", ")" ]

[ "Set", "the", "attribute", "or", "method", "name", "called", "to", "get", "a", "unique", "Id", "." ]

[ "def", "setIdAttr", "(", "self", ",", "id", ")", ":", "self", ".", "_id", "=", "id" ]

[ "Set", "wether", "or", "not", "to", "expand", "the", "root", "node", "by", "default", "." ]

[ "def", "setExpandRoot", "(", "self", ",", "expand", ")", ":", "self", ".", "_expand_root", "=", "expand", "and", "True", "or", "False" ]

[ "Set", "wether", "or", "not", "to", "assume", "nodes", "have", "children", "." ]

[ "def", "setAssumeChildren", "(", "self", ",", "assume", ")", ":", "self", ".", "_assume_children", "=", "assume", "and", "True", "or", "False" ]

[ "Set", "the", "criteria", "for", "fetching", "child", "nodes", "." ]

[ "def", "setChildAccess", "(", "self", ",", "attrname", "=", "_marker", ",", "filter", "=", "_marker", ",", "function", "=", "_marker", ")", ":", "if", "function", "is", "_marker", ":", "self", ".", "_values_function", "=", "None", "if", "attrname", "is", "not", "_marker", ":", "self", ".", "_values", "=", "str", "(", "attrname", ")", "if", "filter", "is", "not", "_marker", ":", "self", ".", "_values_filter", "=", "filter", "else", ":", "self", ".", "_values_function", "=", "function" ]

[ "Set", "the", "expansion", "state", "function", "." ]

[ "def", "setStateFunction", "(", "self", ",", "function", ")", ":", "self", ".", "_state_function", "=", "function" ]

[ "Create", "a", "tree", "from", "root", "with", "specified", "nodes", "expanded", "." ]

[ "def", "tree", "(", "self", ",", "root", ",", "expanded", "=", "None", ",", "subtree", "=", "0", ")", ":", "node", "=", "self", ".", "node", "(", "root", ")", "child_exp", "=", "expanded", "if", "not", "simple_type", "(", "expanded", ")", ":", "# Assume a mapping", "expanded", "=", "node", ".", "id", "in", "expanded", "child_exp", "=", "child_exp", ".", "get", "(", "node", ".", "id", ")", "expanded", "=", "expanded", "or", "(", "not", "subtree", "and", "self", ".", "_expand_root", ")", "# Set state to 0 (leaf), 1 (opened), or -1 (closed)", "state", "=", "self", ".", "hasChildren", "(", "root", ")", "and", "(", "expanded", "or", "-", "1", ")", "if", "self", ".", "_state_function", "is", "not", "None", ":", "state", "=", "self", ".", "_state_function", "(", "node", ".", "object", ",", "state", ")", "node", ".", "state", "=", "state", "if", "state", ">", "0", ":", "for", "child", "in", "self", ".", "getChildren", "(", "root", ")", ":", "node", ".", "_add_child", "(", "self", ".", "tree", "(", "child", ",", "child_exp", ",", "1", ")", ")", "if", "not", "subtree", ":", "node", ".", "depth", "=", "0", "return", "node" ]

[ "trace_param", ":", "ea", "min_ea", "op_type", "op_val" ]

[ "def", "trace_param", "(", "ea", ",", "min_ea", ",", "op_type", ",", "op_val", ")", ":", "global", "displ_re", ",", "msgsend", ",", "var_re", "ea_call", "=", "ea", "while", "ea", "!=", "idc", ".", "BADADDR", "and", "ea", "!=", "min_ea", ":", "ea", "=", "idc", ".", "PrevHead", "(", "ea", ",", "min_ea", ")", "if", "op_type", "==", "idaapi", ".", "o_reg", "and", "op_val", "==", "0", "and", "idaapi", ".", "is_call_insn", "(", "ea", ")", ":", "# We have a BL/BLX that will modify the R0", "# we're tracking", "#", "return", "None", "if", "idc", ".", "GetMnem", "(", "ea", ")", "in", "[", "'LDR'", ",", "'MOV'", "]", ":", "src_op", "=", "1", "dest_op", "=", "0", "elif", "idc", ".", "GetMnem", "(", "ea", ")", "==", "'STR'", ":", "src_op", "=", "0", "dest_op", "=", "1", "else", ":", "continue", "if", "idc", ".", "GetOpType", "(", "ea", ",", "dest_op", ")", "==", "op_type", "and", "idc", ".", "GetOperandValue", "(", "ea", ",", "dest_op", ")", "==", "op_val", ":", "# Found, see where it comes from", "if", "idc", ".", "GetOpType", "(", "ea", ",", "src_op", ")", "==", "idc", ".", "o_mem", ":", "# Got the final reference", "refs", "=", "list", "(", "idautils", ".", "DataRefsFrom", "(", "ea", ")", ")", "if", "not", "refs", ":", "local_ref", "=", "idc", ".", "GetOperandValue", "(", "ea", ",", "src_op", ")", "far_ref", "=", "idc", ".", "Dword", "(", "local_ref", ")", "else", ":", "while", "len", "(", "refs", ")", ">", "0", ":", "far_ref", "=", "refs", "[", "0", "]", "refs", "=", "list", "(", "idautils", ".", "DataRefsFrom", "(", "refs", "[", "0", "]", ")", ")", "return", "far_ref", "elif", "idc", ".", "GetOpType", "(", "ea", ",", "src_op", ")", "==", "idc", ".", "o_displ", ":", "if", "', [SP'", "in", "idc", ".", "GetDisasm", "(", "ea", ")", ":", "if", "'arg_'", "in", "idc", ".", "GetDisasm", "(", "ea", ")", ":", "# We don't track function arguments", "return", "None", "# We're tracking an stack variable", "try", ":", "var_name", "=", "var_re", ".", "search", "(", "idc", ".", "GetDisasm", "(", "ea", ")", ")", ".", "group", "(", "'varname'", ")", "except", ":", "print", "'%08x: Unable to recognize variable'", "%", "ea", "return", "None", "while", "ea", "!=", "idc", ".", "BADADDR", "and", "ea", ">", "min_ea", ":", "if", "idc", ".", "GetMnem", "(", "ea", ")", "==", "'STR'", "and", "var_name", "in", "idc", ".", "GetDisasm", "(", "ea", ")", ":", "# New reg to track", "op_val", "=", "idc", ".", "GetOperandValue", "(", "ea", ",", "dest_op", ")", "break", "ea", "=", "idc", ".", "PrevHead", "(", "ea", ",", "min_ea", ")", "else", ":", "# New reg to track", "if", "'[LR]'", "in", "idc", ".", "GetDisasm", "(", "ea", ")", ":", "# Optimizations use LR as general reg", "op_val", "=", "14", "else", ":", "try", ":", "op_val", "=", "int", "(", "displ_re", ".", "search", "(", "idc", ".", "GetDisasm", "(", "ea", ")", ")", ".", "group", "(", "'regnum'", ")", ")", "except", ":", "print", "'%08x: Unable to recognize register'", "%", "ea", "return", "None", "elif", "idc", ".", "GetOpType", "(", "ea", ",", "src_op", ")", "==", "idc", ".", "o_reg", ":", "# Direct reg-reg assignment", "op_val", "=", "idc", ".", "GetOperandValue", "(", "ea", ",", "src_op", ")", "else", ":", "# We don't track o_phrase or other complex source operands :(", "return", "None", "return", "None" ]

[ "fix_callgraph", ":", "msgsend", "segname", "class_param", "sel_param" ]

[ "def", "fix_callgraph", "(", "msgsend", ",", "segname", ",", "class_param", ",", "sel_param", ")", ":", "t1", "=", "time", ".", "time", "(", ")", "if", "not", "msgsend", ":", "print", "'ERROR: msgSend not found'", "return", "total", "=", "0", "resolved", "=", "0", "call_table", "=", "dict", "(", ")", "for", "xref", "in", "idautils", ".", "XrefsTo", "(", "msgsend", ",", "idaapi", ".", "XREF_ALL", ")", ":", "total", "+=", "1", "ea_call", "=", "xref", ".", "frm", "func_start", "=", "idc", ".", "GetFunctionAttr", "(", "ea_call", ",", "idc", ".", "FUNCATTR_START", ")", "if", "not", "func_start", "or", "func_start", "==", "idc", ".", "BADADDR", ":", "continue", "ea", "=", "ea_call", "method_name_ea", "=", "trace_param", "(", "ea", ",", "func_start", ",", "idc", ".", "o_reg", ",", "sel_param", ")", "if", "method_name_ea", "and", "idc", ".", "isASCII", "(", "idc", ".", "GetFlags", "(", "method_name_ea", ")", ")", ":", "method_name", "=", "idc", ".", "GetString", "(", "method_name_ea", ",", "-", "1", ",", "idc", ".", "ASCSTR_C", ")", "if", "not", "method_name", ":", "method_name", "=", "'_unk_method'", "else", ":", "method_name", "=", "'_unk_method'", "class_name_ea", "=", "trace_param", "(", "ea", ",", "func_start", ",", "idc", ".", "o_reg", ",", "class_param", ")", "if", "class_name_ea", ":", "class_name", "=", "idc", ".", "Name", "(", "class_name_ea", ")", "if", "not", "class_name", ":", "class_name", "=", "'_unk_class'", "else", ":", "class_name", "=", "'_unk_class'", "if", "method_name", "==", "'_unk_method'", "and", "class_name", "==", "'_unk_class'", ":", "continue", "# Using this name convention, if the class and method", "# are identified by IDA, the patched call will point to", "# the REAL call and not one of our dummy functions", "#", "class_name", "=", "class_name", ".", "replace", "(", "'_OBJC_CLASS_$_'", ",", "''", ")", "class_name", "=", "class_name", ".", "replace", "(", "'_OBJC_METACLASS_$_'", ",", "''", ")", "new_name", "=", "'_['", "+", "class_name", "+", "'_'", "+", "method_name", "+", "']'", "print", "'%08x: %s'", "%", "(", "ea_call", ",", "new_name", ")", "call_table", "[", "ea_call", "]", "=", "new_name", "resolved", "+=", "1", "print", "'\\nFinal stats:\\n\\t%d total calls, %d resolved'", "%", "(", "total", ",", "resolved", ")", "print", "'\\tAnalysis took %.2f seconds'", "%", "(", "time", ".", "time", "(", ")", "-", "t1", ")", "if", "resolved", "==", "0", ":", "print", "'Nothing to patch.'", "return", "print", "'Adding new segment to store new nullsubs'", "# segment size = opcode ret (4 bytes) * num_calls", "seg_size", "=", "resolved", "*", "4", "seg_start", "=", "idc", ".", "MaxEA", "(", ")", "+", "4", "idaapi", ".", "add_segm", "(", "0", ",", "seg_start", ",", "seg_start", "+", "seg_size", ",", "segname", ",", "'CODE'", ")", "print", "'Patching database...'", "seg_ptr", "=", "seg_start", "for", "ea", ",", "new_name", "in", "call_table", ".", "items", "(", ")", ":", "if", "idc", ".", "LocByName", "(", "new_name", ")", "!=", "idc", ".", "BADADDR", ":", "offset", "=", "idc", ".", "LocByName", "(", "new_name", ")", "-", "ea", "else", ":", "# create code and name it", "idc", ".", "PatchDword", "(", "seg_ptr", ",", "0xE12FFF1E", ")", "# BX LR", "idc", ".", "MakeName", "(", "seg_ptr", ",", "new_name", ")", "idc", ".", "MakeCode", "(", "seg_ptr", ")", "idc", ".", "MakeFunction", "(", "seg_ptr", ",", "seg_ptr", "+", "4", ")", "idc", ".", "MakeRptCmt", "(", "seg_ptr", ",", "new_name", ")", "offset", "=", "seg_ptr", "-", "ea", "seg_ptr", "+=", "4", "# patch the msgsend call", "if", "idc", ".", "GetReg", "(", "ea", ",", "\"T\"", ")", "==", "1", ":", "if", "offset", ">", "0", "and", "offset", "&", "0xFF800000", ":", "print", "'Offset too far for Thumb (%08x) Stopping [%08x]'", "%", "(", "offset", ",", "ea", ")", "return", "off1", "=", "(", "offset", "&", "0x7FF000", ")", ">>", "12", "off2", "=", "(", "offset", "&", "0xFFF", ")", "/", "2", "w1", "=", "(", "0xF000", "|", "off1", ")", "w2", "=", "(", "0xE800", "|", "off2", ")", "-", "1", "idc", ".", "PatchWord", "(", "ea", ",", "w1", ")", "idc", ".", "PatchWord", "(", "ea", "+", "2", ",", "w2", ")", "else", ":", "if", "offset", ">", "0", "and", "offset", "&", "0xFF000000", ":", "print", "'Offset too far (%08x) Stopping [%08x]'", "%", "(", "offset", ",", "ea", ")", "dw", "=", "(", "0xFA000000", "|", "(", "offset", "-", "8", ">>", "2", ")", ")", "if", "dw", "<", "0", ":", "dw", "=", "dw", "&", "0xFAFFFFFF", "idc", ".", "PatchDword", "(", "ea", ",", "dw", ")" ]

[ "trace_param", ":", "ea", "min_ea", "op_type", "op_val" ]

[ "def", "track_param", "(", "ea", ",", "min_ea", ",", "op_type", ",", "op_val", ")", ":", "global", "msgsend", ",", "var_re", "ea_call", "=", "ea", "while", "ea", "!=", "idc", ".", "BADADDR", "and", "ea", "!=", "min_ea", ":", "ea", "=", "idc", ".", "PrevHead", "(", "ea", ",", "min_ea", ")", "if", "idc", ".", "GetMnem", "(", "ea", ")", "not", "in", "[", "'lea'", ",", "'mov'", "]", ":", "continue", "if", "idc", ".", "GetOpType", "(", "ea", ",", "0", ")", "==", "op_type", "and", "idc", ".", "GetOperandValue", "(", "ea", ",", "0", ")", "==", "op_val", ":", "if", "idc", ".", "GetOpType", "(", "ea", ",", "1", ")", "==", "idc", ".", "o_displ", ":", "if", "', [esp'", "in", "idc", ".", "GetDisasm", "(", "ea", ")", "or", "', [ebp'", "in", "idc", ".", "GetDisasm", "(", "ea", ")", ":", "if", "'arg_'", "in", "idc", ".", "GetDisasm", "(", "ea", ")", ":", "# We don't track function arguments", "return", "None", "# We only track stack variables", "try", ":", "var_name", "=", "var_re", ".", "search", "(", "idc", ".", "GetDisasm", "(", "ea", ")", ")", ".", "group", "(", "'varname'", ")", "op_type", "=", "idc", ".", "GetOpType", "(", "ea", ",", "1", ")", "except", ":", "print", "'%08x: Unable to recognize variable'", "%", "ea", "return", "None", "while", "ea", "!=", "idc", ".", "BADADDR", "and", "ea", ">", "min_ea", ":", "if", "idc", ".", "GetMnem", "(", "ea", ")", "==", "'mov'", "or", "idc", ".", "GetMnem", "(", "ea", ")", "==", "'lea'", "and", "var_name", "in", "idc", ".", "GetDisasm", "(", "ea", ")", ":", "# New reg to track", "op_val", "=", "idc", ".", "GetOperandValue", "(", "ea", ",", "0", ")", "break", "ea", "=", "idc", ".", "PrevHead", "(", "ea", ",", "min_ea", ")", "elif", "idc", ".", "GetOpType", "(", "ea", ",", "1", ")", "==", "idc", ".", "o_mem", ":", "# Got the final reference", "refs", "=", "list", "(", "idautils", ".", "DataRefsFrom", "(", "ea", ")", ")", "if", "not", "refs", ":", "local_ref", "=", "idc", ".", "GetOperandValue", "(", "ea", ",", "1", ")", "far_ref", "=", "idc", ".", "Dword", "(", "local_ref", ")", "else", ":", "while", "len", "(", "refs", ")", ">", "0", ":", "far_ref", "=", "refs", "[", "0", "]", "refs", "=", "list", "(", "idautils", ".", "DataRefsFrom", "(", "refs", "[", "0", "]", ")", ")", "return", "far_ref", "elif", "idc", ".", "GetOpType", "(", "ea", ",", "1", ")", "==", "idc", ".", "o_reg", ":", "# Direct reg-reg assignment", "op_val", "=", "idc", ".", "GetOperandValue", "(", "ea", ",", "1", ")", "op_type", "=", "idc", ".", "GetOpType", "(", "ea", ",", "1", ")", "else", ":", "# We don't track o_phrase or other complex source operands :(", "return", "None", "return", "None" ]

[ "fix_callgraph", ":", "msgsend", "segname", "class_param", "sel_param" ]

[ "def", "fix_callgraph", "(", "msgsend", ",", "segname", ",", "class_param", ",", "sel_param", ")", ":", "t1", "=", "time", ".", "time", "(", ")", "if", "not", "msgsend", ":", "print", "'ERROR: msgSend not found'", "return", "total", "=", "0", "resolved", "=", "0", "call_table", "=", "dict", "(", ")", "for", "xref", "in", "idautils", ".", "XrefsTo", "(", "msgsend", ",", "idaapi", ".", "XREF_ALL", ")", ":", "total", "+=", "1", "ea_call", "=", "xref", ".", "frm", "func_start", "=", "idc", ".", "GetFunctionAttr", "(", "ea_call", ",", "idc", ".", "FUNCATTR_START", ")", "if", "not", "func_start", "or", "func_start", "==", "idc", ".", "BADADDR", ":", "continue", "ea", "=", "ea_call", "method_name_ea", "=", "track_param", "(", "ea", ",", "func_start", ",", "idc", ".", "o_displ", ",", "sel_param", ")", "if", "method_name_ea", ":", "method_name", "=", "idc", ".", "GetString", "(", "method_name_ea", ",", "-", "1", ",", "idc", ".", "ASCSTR_C", ")", "if", "not", "method_name", ":", "method_name", "=", "''", "else", ":", "method_name", "=", "''", "class_name_ea", "=", "track_param", "(", "ea", ",", "func_start", ",", "idc", ".", "o_phrase", ",", "class_param", ")", "if", "class_name_ea", ":", "class_name", "=", "idc", ".", "GetString", "(", "class_name_ea", ",", "-", "1", ",", "idc", ".", "ASCSTR_C", ")", "if", "not", "class_name", ":", "class_name", "=", "''", "else", ":", "class_name", "=", "''", "if", "not", "method_name", "and", "not", "class_name", ":", "continue", "# Using this name convention, if the class and method", "# are identified by IDA, the patched call will point to", "# the REAL call and not one of our dummy functions", "#", "class_name", "=", "class_name", ".", "replace", "(", "'_objc_class_name_'", ",", "''", ")", "new_name", "=", "'_['", "+", "class_name", "+", "'_'", "+", "method_name", "+", "']'", "call_table", "[", "ea_call", "]", "=", "new_name", "resolved", "+=", "1", "print", "'\\nFinal stats:\\n\\t%d total calls, %d resolved'", "%", "(", "total", ",", "resolved", ")", "print", "'\\tAnalysis took %.2f seconds'", "%", "(", "time", ".", "time", "(", ")", "-", "t1", ")", "if", "resolved", "==", "0", ":", "print", "'Nothing to patch.'", "return", "print", "'Adding new segment to store new nullsubs'", "# segment size = opcode ret (4 bytes) * num_calls", "seg_size", "=", "resolved", "*", "4", "seg_start", "=", "idc", ".", "MaxEA", "(", ")", "+", "4", "idaapi", ".", "add_segm", "(", "0", ",", "seg_start", ",", "seg_start", "+", "seg_size", ",", "segname", ",", "'CODE'", ")", "print", "'Patching database...'", "seg_ptr", "=", "seg_start", "for", "ea", ",", "new_name", "in", "call_table", ".", "items", "(", ")", ":", "if", "idc", ".", "LocByName", "(", "new_name", ")", "!=", "idc", ".", "BADADDR", ":", "offset", "=", "(", "idc", ".", "LocByName", "(", "new_name", ")", "-", "ea", ")", "&", "idc", ".", "BADADDR", "else", ":", "# create code and name it", "idc", ".", "PatchDword", "(", "seg_ptr", ",", "0x90", ")", "# nop", "idc", ".", "MakeName", "(", "seg_ptr", ",", "new_name", ")", "idc", ".", "MakeCode", "(", "seg_ptr", ")", "idc", ".", "MakeFunction", "(", "seg_ptr", ",", "seg_ptr", "+", "4", ")", "idc", ".", "MakeRptCmt", "(", "seg_ptr", ",", "new_name", ")", "offset", "=", "seg_ptr", "-", "ea", "seg_ptr", "+=", "4", "dw", "=", "offset", "-", "5", "idc", ".", "PatchByte", "(", "ea", ",", "0xE8", ")", "idc", ".", "PatchDword", "(", "ea", "+", "1", ",", "dw", ")" ]

[ "with", "open", "(", "word_hash", ".", "txt", "w", ")", "as", "outs", ":", "for", "word", "in", "word_list", ":", "outs", ".", "write", "(", "word", "+", "\\", "t", "+", "str", "(", "self", ".", "_string_hash", "(", "word", "))", "+", "os", ".", "linesep", ")" ]

[ "def", "__init__", "(", "self", ",", "word_list", "=", "[", "]", ",", "hashbits", "=", "128", ")", ":", "self", ".", "hashbits", "=", "hashbits", "self", ".", "hashval_list", "=", "[", "self", ".", "_string_hash", "(", "word", ")", "for", "word", "in", "word_list", "]", "print", "'Totally: %s words'", "%", "(", "len", "(", "self", ".", "hashval_list", ")", ",", ")" ]

[ "Defines", "all", "arguments", ".", "Returns", "-------", "args", "object", "that", "contains", "all", "the", "params" ]

[ "def", "parse_args", "(", ")", ":", "parser", "=", "argparse", ".", "ArgumentParser", "(", "formatter_class", "=", "argparse", ".", "ArgumentDefaultsHelpFormatter", ",", "description", "=", "'test'", ")", "parser", ".", "add_argument", "(", "'filename'", ",", "help", "=", "'path to test list file.'", ")", "parser", ".", "add_argument", "(", "'--load-epoch'", ",", "default", "=", "73", ",", "help", "=", "'load the model on an epoch using the model-load-prefix'", ")", "args", "=", "parser", ".", "parse_args", "(", ")", "return", "args" ]

[ "Defines", "all", "arguments", ".", "Returns", "-------", "args", "object", "that", "contains", "all", "the", "params" ]

[ "def", "parse_args", "(", ")", ":", "parser", "=", "argparse", ".", "ArgumentParser", "(", "formatter_class", "=", "argparse", ".", "ArgumentDefaultsHelpFormatter", ",", "description", "=", "'Create an image list or \\\n make a record database by reading from an image list'", ")", "# parser.add_argument('--train', action='store_true',", "# help='generate train/val list file & resize train/val image to 112 size which saved in ../phase1/ dir.')", "parser", ".", "add_argument", "(", "'train'", ",", "help", "=", "'generate train/val list file & resize train/val image to 112 size which saved in ../phase1/ dir.'", ")", "cgroup", "=", "parser", ".", "add_argument_group", "(", "'Options for creating image lists'", ")", "cgroup", ".", "add_argument", "(", "'--no-enmfake'", ",", "action", "=", "'store_true'", ",", "default", "=", "False", ",", "help", "=", "'remove enm fake train image dataset'", ")", "cgroup", ".", "add_argument", "(", "'--aug'", ",", "action", "=", "'store_true'", ",", "default", "=", "False", ",", "help", "=", "'augment train positive image dataset'", ")", "args", "=", "parser", ".", "parse_args", "(", ")", "return", "args" ]

[ "Defines", "all", "arguments", ".", "Returns", "-------", "args", "object", "that", "contains", "all", "the", "params" ]

[ "def", "parse_args", "(", ")", ":", "parser", "=", "argparse", ".", "ArgumentParser", "(", "formatter_class", "=", "argparse", ".", "ArgumentDefaultsHelpFormatter", ",", "description", "=", "'test'", ")", "parser", ".", "add_argument", "(", "'filename'", ",", "help", "=", "'path to test list file.'", ")", "parser", ".", "add_argument", "(", "'--load-epoch'", ",", "default", "=", "73", ",", "help", "=", "'load the model on an epoch using the model-load-prefix'", ")", "args", "=", "parser", ".", "parse_args", "(", ")", "return", "args" ]

[ "return", "a", "list", "of", "GPUs" ]

[ "def", "get_gpus", "(", ")", ":", "try", ":", "re", "=", "subprocess", ".", "check_output", "(", "[", "\"nvidia-smi\"", ",", "\"-L\"", "]", ",", "universal_newlines", "=", "True", ")", "except", "OSError", ":", "return", "[", "]", "return", "range", "(", "len", "(", "[", "i", "for", "i", "in", "re", ".", "split", "(", "'\\n'", ")", "if", "'GPU'", "in", "i", "]", ")", ")" ]

[ "parser", ":", "argparse", ".", "ArgumentParser", "return", "a", "parser", "added", "with", "args", "required", "by", "fit" ]

[ "def", "add_fit_args", "(", "parser", ")", ":", "train", "=", "parser", ".", "add_argument_group", "(", "'Training'", ",", "'model training'", ")", "train", ".", "add_argument", "(", "'--network'", ",", "type", "=", "str", ",", "help", "=", "'the neural network to use'", ")", "train", ".", "add_argument", "(", "'--num-layers'", ",", "type", "=", "int", ",", "help", "=", "'number of layers in the neural network, required by some networks such as resnet'", ")", "train", ".", "add_argument", "(", "'--gpus'", ",", "type", "=", "str", ",", "help", "=", "'list of gpus to run, e.g. 0 or 0,2,5. empty means using cpu'", ")", "train", ".", "add_argument", "(", "'--kv-store'", ",", "type", "=", "str", ",", "default", "=", "'device'", ",", "help", "=", "'key-value store type'", ")", "train", ".", "add_argument", "(", "'--num-epochs'", ",", "type", "=", "int", ",", "default", "=", "100", ",", "help", "=", "'max num of epochs'", ")", "train", ".", "add_argument", "(", "'--lr'", ",", "type", "=", "float", ",", "default", "=", "0.1", ",", "help", "=", "'initial learning rate'", ")", "train", ".", "add_argument", "(", "'--lr-factor'", ",", "type", "=", "float", ",", "default", "=", "0.1", ",", "help", "=", "'the ratio to reduce lr on each step'", ")", "train", ".", "add_argument", "(", "'--lr-step-epochs'", ",", "type", "=", "str", ",", "help", "=", "'the epochs to reduce the lr, e.g. 30,60'", ")", "train", ".", "add_argument", "(", "'--optimizer'", ",", "type", "=", "str", ",", "default", "=", "'sgd'", ",", "help", "=", "'the optimizer type'", ")", "train", ".", "add_argument", "(", "'--mom'", ",", "type", "=", "float", ",", "default", "=", "0.9", ",", "help", "=", "'momentum for sgd'", ")", "train", ".", "add_argument", "(", "'--wd'", ",", "type", "=", "float", ",", "default", "=", "0.0001", ",", "help", "=", "'weight decay for sgd'", ")", "train", ".", "add_argument", "(", "'--batch-size'", ",", "type", "=", "int", ",", "default", "=", "128", ",", "help", "=", "'the batch size'", ")", "train", ".", "add_argument", "(", "'--disp-batches'", ",", "type", "=", "int", ",", "default", "=", "20", ",", "help", "=", "'show progress for every n batches'", ")", "train", ".", "add_argument", "(", "'--model-prefix'", ",", "type", "=", "str", ",", "help", "=", "'model prefix'", ")", "parser", ".", "add_argument", "(", "'--monitor'", ",", "dest", "=", "'monitor'", ",", "type", "=", "int", ",", "default", "=", "0", ",", "help", "=", "'log network parameters every N iters if larger than 0'", ")", "train", ".", "add_argument", "(", "'--load-epoch'", ",", "type", "=", "int", ",", "help", "=", "'load the model on an epoch using the model-load-prefix'", ")", "train", ".", "add_argument", "(", "'--top-k'", ",", "type", "=", "int", ",", "default", "=", "0", ",", "help", "=", "'report the top-k accuracy. 0 means no report.'", ")", "train", ".", "add_argument", "(", "'--test-io'", ",", "type", "=", "int", ",", "default", "=", "0", ",", "help", "=", "'1 means test reading speed without training'", ")", "train", ".", "add_argument", "(", "'--dtype'", ",", "type", "=", "str", ",", "default", "=", "'float32'", ",", "help", "=", "'precision: float32 or float16'", ")", "return", "train" ]

[ "train", "a", "model", "args", ":", "argparse", "returns", "network", ":", "the", "symbol", "definition", "of", "the", "nerual", "network", "data_loader", ":", "function", "that", "returns", "the", "train", "and", "val", "data", "iterators" ]

[ "def", "fit", "(", "args", ",", "network", ",", "data_loader", ",", "*", "*", "kwargs", ")", ":", "# kvstore", "kv", "=", "mx", ".", "kvstore", ".", "create", "(", "args", ".", "kv_store", ")", "# logging", "head", "=", "'%(asctime)-15s Node['", "+", "str", "(", "kv", ".", "rank", ")", "+", "'] %(message)s'", "logging", ".", "basicConfig", "(", "level", "=", "logging", ".", "DEBUG", ",", "format", "=", "head", ")", "logging", ".", "info", "(", "'start with arguments %s'", ",", "args", ")", "# data iterators", "(", "train", ",", "val", ")", "=", "data_loader", "(", "args", ",", "kv", ")", "if", "args", ".", "test_io", ":", "tic", "=", "time", ".", "time", "(", ")", "for", "i", ",", "batch", "in", "enumerate", "(", "train", ")", ":", "for", "j", "in", "batch", ".", "data", ":", "j", ".", "wait_to_read", "(", ")", "if", "(", "i", "+", "1", ")", "%", "args", ".", "disp_batches", "==", "0", ":", "logging", ".", "info", "(", "'Batch [%d]\\tSpeed: %.2f samples/sec'", "%", "(", "i", ",", "args", ".", "disp_batches", "*", "args", ".", "batch_size", "/", "(", "time", ".", "time", "(", ")", "-", "tic", ")", ")", ")", "tic", "=", "time", ".", "time", "(", ")", "return", "# load model", "if", "'arg_params'", "in", "kwargs", "and", "'aux_params'", "in", "kwargs", ":", "arg_params", "=", "kwargs", "[", "'arg_params'", "]", "aux_params", "=", "kwargs", "[", "'aux_params'", "]", "else", ":", "sym", ",", "arg_params", ",", "aux_params", "=", "_load_model", "(", "args", ",", "kv", ".", "rank", ")", "if", "sym", "is", "not", "None", ":", "assert", "sym", ".", "tojson", "(", ")", "==", "network", ".", "tojson", "(", ")", "# save model", "checkpoint", "=", "_save_model", "(", "args", ",", "kv", ".", "rank", ")", "# devices for training", "devs", "=", "mx", ".", "cpu", "(", ")", "if", "args", ".", "gpus", "is", "None", "or", "args", ".", "gpus", "is", "''", "else", "[", "mx", ".", "gpu", "(", "int", "(", "i", ")", ")", "for", "i", "in", "args", ".", "gpus", ".", "split", "(", "','", ")", "]", "# learning rate", "lr", ",", "lr_scheduler", "=", "_get_lr_scheduler", "(", "args", ",", "kv", ")", "# create model", "model", "=", "mx", ".", "mod", ".", "Module", "(", "context", "=", "devs", ",", "symbol", "=", "network", ")", "lr_scheduler", "=", "lr_scheduler", "optimizer_params", "=", "{", "'learning_rate'", ":", "lr", ",", "'wd'", ":", "args", ".", "wd", ",", "'lr_scheduler'", ":", "lr_scheduler", "}", "# Add 'multi_precision' parameter only for SGD optimizer", "if", "args", ".", "optimizer", "==", "'sgd'", ":", "optimizer_params", "[", "'multi_precision'", "]", "=", "True", "# Only a limited number of optimizers have 'momentum' property", "has_momentum", "=", "{", "'sgd'", ",", "'dcasgd'", ",", "'nag'", "}", "if", "args", ".", "optimizer", "in", "has_momentum", ":", "optimizer_params", "[", "'momentum'", "]", "=", "args", ".", "mom", "monitor", "=", "mx", ".", "mon", ".", "Monitor", "(", "args", ".", "monitor", ",", "pattern", "=", "\".*\"", ")", "if", "args", ".", "monitor", ">", "0", "else", "None", "if", "args", ".", "network", "==", "'alexnet'", ":", "# AlexNet will not converge using Xavier", "initializer", "=", "mx", ".", "init", ".", "Normal", "(", ")", "elif", "args", ".", "network", "in", "[", "'shufflenet'", ",", "'shufflenet_v2'", ",", "'zkflow_shufflenet_v2'", ",", "'mobilenet'", ",", "'mobilenetv2'", ",", "'zkflow_mobilenet'", ",", "'vmspoofface'", ",", "'vmspoofnet'", ",", "'vmspoofnet_v2'", "]", ":", "initializer", "=", "mx", ".", "init", ".", "Uniform", "(", ")", "else", ":", "initializer", "=", "mx", ".", "init", ".", "Xavier", "(", "rnd_type", "=", "'gaussian'", ",", "factor_type", "=", "\"in\"", ",", "magnitude", "=", "2", ")", "# initializer = mx.init.Xavier(factor_type=\"in\", magnitude=2.34),", "# evaluation metrices", "eval_metrics", "=", "[", "'accuracy'", ",", "'f1'", "]", "if", "args", ".", "top_k", ">", "0", ":", "eval_metrics", ".", "append", "(", "mx", ".", "metric", ".", "create", "(", "'top_k_accuracy'", ",", "top_k", "=", "args", ".", "top_k", ")", ")", "# callbacks that run after each batch", "batch_end_callbacks", "=", "[", "mx", ".", "callback", ".", "Speedometer", "(", "args", ".", "batch_size", ",", "args", ".", "disp_batches", ")", "]", "if", "'batch_end_callback'", "in", "kwargs", ":", "cbs", "=", "kwargs", "[", "'batch_end_callback'", "]", "batch_end_callbacks", "+=", "cbs", "if", "isinstance", "(", "cbs", ",", "list", ")", "else", "[", "cbs", "]", "# run", "model", ".", "fit", "(", "train", ",", "begin_epoch", "=", "args", ".", "load_epoch", "if", "args", ".", "load_epoch", "else", "0", ",", "num_epoch", "=", "args", ".", "num_epochs", ",", "eval_data", "=", "val", ",", "eval_metric", "=", "eval_metrics", ",", "kvstore", "=", "kv", ",", "optimizer", "=", "args", ".", "optimizer", ",", "optimizer_params", "=", "optimizer_params", ",", "initializer", "=", "initializer", ",", "arg_params", "=", "arg_params", ",", "aux_params", "=", "aux_params", ",", "batch_end_callback", "=", "batch_end_callbacks", ",", "epoch_end_callback", "=", "checkpoint", ",", "allow_missing", "=", "True", ",", "monitor", "=", "monitor", ")" ]

[ "Traverses", "the", "root", "of", "directory", "that", "contains", "images", "and", "generates", "image", "list", "iterator", ".", "Parameters", "----------", "root", ":", "string", "recursive", ":", "bool", "exts", ":", "string", "Returns", "-------", "image", "iterator", "that", "contains", "all", "the", "image", "under", "the", "specified", "path" ]

[ "def", "list_image", "(", "root", ",", "recursive", ",", "exts", ")", ":", "i", "=", "0", "if", "recursive", ":", "cat", "=", "{", "}", "labels", "=", "{", "}", "for", "path", ",", "dirs", ",", "files", "in", "os", ".", "walk", "(", "root", ",", "followlinks", "=", "True", ")", ":", "dirs", ".", "sort", "(", ")", "files", ".", "sort", "(", ")", "for", "fname", "in", "files", ":", "fpath", "=", "os", ".", "path", ".", "join", "(", "path", ",", "fname", ")", "suffix", "=", "os", ".", "path", ".", "splitext", "(", "fname", ")", "[", "1", "]", ".", "lower", "(", ")", "if", "os", ".", "path", ".", "isfile", "(", "fpath", ")", "and", "(", "suffix", "in", "exts", ")", ":", "relpath", "=", "os", ".", "path", ".", "relpath", "(", "fpath", ",", "root", ")", "label", "=", "int", "(", "relpath", ".", "split", "(", "'\\\\'", ",", "1", ")", "[", "0", "]", ")", "if", "path", "not", "in", "cat", ":", "cat", "[", "path", "]", "=", "label", "yield", "(", "i", ",", "relpath", ",", "cat", "[", "path", "]", ")", "i", "+=", "1", "for", "k", ",", "v", "in", "sorted", "(", "cat", ".", "items", "(", ")", ",", "key", "=", "lambda", "x", ":", "x", "[", "1", "]", ")", ":", "relpath", "=", "os", ".", "path", ".", "relpath", "(", "k", ",", "root", ")", "# print('relpath', relpath)", "label", "=", "relpath", ".", "split", "(", "'\\\\'", ",", "1", ")", "[", "0", "]", "# print('label', label)", "print", "(", "relpath", ",", "v", ")", "# print(os.path.relpath(k, root), v)", "else", ":", "for", "fname", "in", "sorted", "(", "os", ".", "listdir", "(", "root", ")", ")", ":", "fpath", "=", "os", ".", "path", ".", "join", "(", "root", ",", "fname", ")", "suffix", "=", "os", ".", "path", ".", "splitext", "(", "fname", ")", "[", "1", "]", ".", "lower", "(", ")", "if", "os", ".", "path", ".", "isfile", "(", "fpath", ")", "and", "(", "suffix", "in", "exts", ")", ":", "yield", "(", "i", ",", "os", ".", "path", ".", "relpath", "(", "fpath", ",", "root", ")", ",", "0", ")", "i", "+=", "1" ]

[ "Hepler", "function", "to", "write", "image", "list", "into", "the", "file", ".", "The", "format", "is", "as", "below", "integer_image_index", "\\", "t", "float_label_index", "\\", "t", "path_to_image", "Note", "that", "the", "blank", "between", "number", "and", "tab", "is", "only", "used", "for", "readability", ".", "Parameters", "----------", "path_out", ":", "string", "image_list", ":", "list" ]

[ "def", "write_list", "(", "path_out", ",", "image_list", ")", ":", "with", "open", "(", "path_out", ",", "'w'", ")", "as", "fout", ":", "for", "i", ",", "item", "in", "enumerate", "(", "image_list", ")", ":", "line", "=", "'%d\\t'", "%", "item", "[", "0", "]", "for", "j", "in", "item", "[", "2", ":", "]", ":", "line", "+=", "'%f\\t'", "%", "j", "line", "+=", "'%s\\n'", "%", "item", "[", "1", "]", "fout", ".", "write", "(", "line", ")" ]