Datasets:

---

CM

/

codexglue_code2text_python

like 8

[ "def", "dependency_context", "(", "package_names", ",", "aggressively_remove", "=", "False", ")", ":", "installed_packages", "=", "[", "]", "log", "=", "logging", ".", "getLogger", "(", "__name__", ")", "try", ":", "if", "not", "package_names", ":", "logging", ".", "debug", "(", "'No packages requested'", ")", "if", "package_names", ":", "lock", "=", "yg", ".", "lockfile", ".", "FileLock", "(", "'/tmp/.pkg-context-lock'", ",", "timeout", "=", "30", "*", "60", ")", "log", ".", "info", "(", "'Acquiring lock to perform install'", ")", "lock", ".", "acquire", "(", ")", "log", ".", "info", "(", "'Installing '", "+", "', '", ".", "join", "(", "package_names", ")", ")", "output", "=", "subprocess", ".", "check_output", "(", "[", "'sudo'", ",", "'aptitude'", ",", "'install'", ",", "'-y'", "]", "+", "package_names", ",", "stderr", "=", "subprocess", ".", "STDOUT", ",", ")", "log", ".", "debug", "(", "'Aptitude output:\\n%s'", ",", "output", ")", "installed_packages", "=", "jaraco", ".", "apt", ".", "parse_new_packages", "(", "output", ",", "include_automatic", "=", "aggressively_remove", ")", "if", "not", "installed_packages", ":", "lock", ".", "release", "(", ")", "log", ".", "info", "(", "'Installed '", "+", "', '", ".", "join", "(", "installed_packages", ")", ")", "yield", "installed_packages", "except", "subprocess", ".", "CalledProcessError", ":", "log", ".", "error", "(", "\"Error occurred installing packages\"", ")", "raise", "finally", ":", "if", "installed_packages", ":", "log", ".", "info", "(", "'Removing '", "+", "','", ".", "join", "(", "installed_packages", ")", ")", "subprocess", ".", "check_call", "(", "[", "'sudo'", ",", "'aptitude'", ",", "'remove'", ",", "'-y'", "]", "+", "installed_packages", ",", "stdout", "=", "subprocess", ".", "PIPE", ",", "stderr", "=", "subprocess", ".", "STDOUT", ",", ")", "lock", ".", "release", "(", ")" ]

[ "Install", "the", "supplied", "packages", "and", "yield", ".", "Finally", "remove", "all", "packages", "that", "were", "installed", ".", "Currently", "assumes", "aptitude", "is", "available", "." ]

[ "def", "tarball_context", "(", "url", ",", "target_dir", "=", "None", ",", "runner", "=", "None", ",", "pushd", "=", "pushd", ")", ":", "if", "target_dir", "is", "None", ":", "target_dir", "=", "os", ".", "path", ".", "basename", "(", "url", ")", ".", "replace", "(", "'.tar.gz'", ",", "''", ")", ".", "replace", "(", "'.tgz'", ",", "''", ")", "if", "runner", "is", "None", ":", "runner", "=", "functools", ".", "partial", "(", "subprocess", ".", "check_call", ",", "shell", "=", "True", ")", "# In the tar command, use --strip-components=1 to strip the first path and", "# then", "# use -C to cause the files to be extracted to {target_dir}. This ensures", "# that we always know where the files were extracted.", "runner", "(", "'mkdir {target_dir}'", ".", "format", "(", "*", "*", "vars", "(", ")", ")", ")", "try", ":", "getter", "=", "'wget {url} -O -'", "extract", "=", "'tar x{compression} --strip-components=1 -C {target_dir}'", "cmd", "=", "' | '", ".", "join", "(", "(", "getter", ",", "extract", ")", ")", "runner", "(", "cmd", ".", "format", "(", "compression", "=", "infer_compression", "(", "url", ")", ",", "*", "*", "vars", "(", ")", ")", ")", "with", "pushd", "(", "target_dir", ")", ":", "yield", "target_dir", "finally", ":", "runner", "(", "'rm -Rf {target_dir}'", ".", "format", "(", "*", "*", "vars", "(", ")", ")", ")" ]

[ "Get", "a", "tarball", "extract", "it", "change", "to", "that", "directory", "yield", "then", "clean", "up", ".", "runner", "is", "the", "function", "to", "invoke", "commands", ".", "pushd", "is", "a", "context", "manager", "for", "changing", "the", "directory", "." ]

[ "def", "infer_compression", "(", "url", ")", ":", "# cheat and just assume it's the last two characters", "compression_indicator", "=", "url", "[", "-", "2", ":", "]", "mapping", "=", "dict", "(", "gz", "=", "'z'", ",", "bz", "=", "'j'", ",", "xz", "=", "'J'", ",", ")", "# Assume 'z' (gzip) if no match", "return", "mapping", ".", "get", "(", "compression_indicator", ",", "'z'", ")" ]

[ "Given", "a", "URL", "or", "filename", "infer", "the", "compression", "code", "for", "tar", "." ]

[ "def", "temp_dir", "(", "remover", "=", "shutil", ".", "rmtree", ")", ":", "temp_dir", "=", "tempfile", ".", "mkdtemp", "(", ")", "try", ":", "yield", "temp_dir", "finally", ":", "remover", "(", "temp_dir", ")" ]

[ "Create", "a", "temporary", "directory", "context", ".", "Pass", "a", "custom", "remover", "to", "override", "the", "removal", "behavior", "." ]

[ "def", "repo_context", "(", "url", ",", "branch", "=", "None", ",", "quiet", "=", "True", ",", "dest_ctx", "=", "temp_dir", ")", ":", "exe", "=", "'git'", "if", "'git'", "in", "url", "else", "'hg'", "with", "dest_ctx", "(", ")", "as", "repo_dir", ":", "cmd", "=", "[", "exe", ",", "'clone'", ",", "url", ",", "repo_dir", "]", "if", "branch", ":", "cmd", ".", "extend", "(", "[", "'--branch'", ",", "branch", "]", ")", "devnull", "=", "open", "(", "os", ".", "path", ".", "devnull", ",", "'w'", ")", "stdout", "=", "devnull", "if", "quiet", "else", "None", "subprocess", ".", "check_call", "(", "cmd", ",", "stdout", "=", "stdout", ")", "yield", "repo_dir" ]

[ "Check", "out", "the", "repo", "indicated", "by", "url", "." ]

[ "def", "device_from_request", "(", "request", ")", ":", "from", "yacms", ".", "conf", "import", "settings", "try", ":", "# If a device was set via cookie, match available devices.", "for", "(", "device", ",", "_", ")", "in", "settings", ".", "DEVICE_USER_AGENTS", ":", "if", "device", "==", "request", ".", "COOKIES", "[", "\"yacms-device\"", "]", ":", "return", "device", "except", "KeyError", ":", "# If a device wasn't set via cookie, match user agent.", "try", ":", "user_agent", "=", "request", ".", "META", "[", "\"HTTP_USER_AGENT\"", "]", ".", "lower", "(", ")", "except", "KeyError", ":", "pass", "else", ":", "try", ":", "user_agent", "=", "user_agent", ".", "decode", "(", "\"utf-8\"", ")", "for", "(", "device", ",", "ua_strings", ")", "in", "settings", ".", "DEVICE_USER_AGENTS", ":", "for", "ua_string", "in", "ua_strings", ":", "if", "ua_string", ".", "lower", "(", ")", "in", "user_agent", ":", "return", "device", "except", "(", "AttributeError", ",", "UnicodeDecodeError", ",", "UnicodeEncodeError", ")", ":", "pass", "return", "\"\"" ]

[ "Determine", "s", "the", "device", "name", "from", "the", "request", "by", "first", "looking", "for", "an", "overridding", "cookie", "and", "if", "not", "found", "then", "matching", "the", "user", "agent", ".", "Used", "at", "both", "the", "template", "level", "for", "choosing", "the", "template", "to", "load", "and", "also", "at", "the", "cache", "level", "as", "a", "cache", "key", "prefix", "." ]

[ "def", "body", "(", "self", ")", ":", "if", "self", ".", "_body", "is", "None", ":", "if", "self", ".", "_fieldstorage", "is", "not", "None", ":", "raise", "ReadBodyTwiceError", "(", ")", "clength", "=", "int", "(", "self", ".", "environ", "(", "'CONTENT_LENGTH'", ")", "or", "0", ")", "self", ".", "_body", "=", "self", ".", "_environ", "[", "'wsgi.input'", "]", ".", "read", "(", "clength", ")", "if", "isinstance", "(", "self", ".", "_body", ",", "bytes", ")", ":", "self", ".", "_body", "=", "self", ".", "_body", ".", "decode", "(", "'utf8'", ")", "return", "self", ".", "_body" ]

[ "String", "from", "wsgi", ".", "input", "." ]

[ "def", "fieldstorage", "(", "self", ")", ":", "if", "self", ".", "_fieldstorage", "is", "None", ":", "if", "self", ".", "_body", "is", "not", "None", ":", "raise", "ReadBodyTwiceError", "(", ")", "self", ".", "_fieldstorage", "=", "cgi", ".", "FieldStorage", "(", "environ", "=", "self", ".", "_environ", ",", "fp", "=", "self", ".", "_environ", "[", "'wsgi.input'", "]", ")", "return", "self", ".", "_fieldstorage" ]

[ "cgi", ".", "FieldStorage", "from", "wsgi", ".", "input", "." ]

[ "def", "params", "(", "self", ")", ":", "if", "self", ".", "_params", "is", "None", ":", "self", ".", "_params", "=", "self", ".", "arg_container", "(", ")", "data", "=", "compat", ".", "parse_qs", "(", "self", ".", "environ", "(", "'QUERY_STRING'", ")", "or", "''", ")", "for", "k", ",", "v", "in", "data", ".", "items", "(", ")", ":", "self", ".", "_params", "[", "k", "]", "=", "v", "[", "0", "]", "return", "self", ".", "_params" ]

[ "Parsed", "query", "string", "." ]

[ "def", "cookie", "(", "self", ")", ":", "if", "self", ".", "_cookie", "is", "None", ":", "self", ".", "_cookie", "=", "self", ".", "arg_container", "(", ")", "data", "=", "compat", ".", "parse_qs", "(", "self", ".", "http_header", "(", "'cookie'", ")", "or", "''", ")", "for", "k", ",", "v", "in", "data", ".", "items", "(", ")", ":", "self", ".", "_cookie", "[", "k", ".", "strip", "(", ")", "]", "=", "v", "[", "0", "]", "return", "self", ".", "_cookie" ]

[ "Cookie", "values", "." ]

[ "def", "data", "(", "self", ")", ":", "if", "self", ".", "_data", "is", "None", ":", "self", ".", "_data", "=", "self", ".", "arg_container", "(", ")", "if", "isinstance", "(", "self", ".", "fieldstorage", ".", "value", ",", "list", ")", ":", "for", "k", "in", "self", ".", "fieldstorage", ".", "keys", "(", ")", ":", "fname", "=", "self", ".", "fieldstorage", "[", "k", "]", ".", "filename", "if", "fname", ":", "self", ".", "_data", "[", "k", "]", "=", "(", "fname", ",", "self", ".", "fieldstorage", "[", "k", "]", ".", "file", ")", "else", ":", "self", ".", "_data", "[", "k", "]", "=", "self", ".", "fieldstorage", ".", "getfirst", "(", "k", ")", "return", "self", ".", "_data" ]

[ "Values", "in", "request", "body", "." ]

[ "def", "drain", "(", "self", ",", "p", ")", ":", "self", ".", "logging", ".", "info", "(", "'Started.'", ")", "fd", "=", "os", ".", "open", "(", "p", ",", "os", ".", "O_RDWR", "|", "os", ".", "O_NONBLOCK", ")", "gevent_os", ".", "make_nonblocking", "(", "fd", ")", "while", "self", ".", "loop", "(", ")", ":", "try", ":", "lines", "=", "gevent_os", ".", "nb_read", "(", "fd", ",", "4096", ")", ".", "splitlines", "(", ")", "if", "len", "(", "lines", ")", "==", "0", ":", "sleep", "(", "0.5", ")", "else", ":", "self", ".", "consume", "(", "lines", ")", "except", "OSError", ":", "pass" ]

[ "Reads", "the", "named", "pipe", "." ]

[ "def", "add", "(", "self", ",", "handler", ",", "name", "=", "None", ",", "exception_handlers", "=", "(", ")", ")", ":", "self", ".", "route", ".", "append", "(", "(", "name", ",", "handler", ",", "exception_handlers", ")", ")" ]

[ "Add", "a", "handler", "to", "the", "route", "." ]

[ "def", "add", "(", "self", ",", "match", ",", "handler", ")", ":", "self", ".", "routes", ".", "append", "(", "(", "match", ",", "(", "Route", "(", "handler", ")", "if", "not", "isinstance", "(", "handler", ",", "Route", ")", "else", "handler", ")", ")", ")" ]

[ "Register", "a", "handler", "with", "the", "Router", "." ]

[ "def", "get_annotated_data_x_y", "(", "timestamps", ",", "data", ",", "lbls", ")", ":", "timestamps", "=", "np", ".", "array", "(", "timestamps", ")", "timestamp_step", "=", "timestamps", "[", "3", "]", "-", "timestamps", "[", "2", "]", "current_new_timestamp", "=", "0.0", "new_timestamps", "=", "[", "]", "X", "=", "None", "Y", "=", "[", "]", "classes", "=", "[", "]", "for", "i", "in", "range", "(", "0", ",", "len", "(", "timestamps", ")", ")", ":", "for", "lbl", "in", "lbls", ":", "if", "lbl", ".", "start_seconds", "<=", "timestamps", "[", "i", "]", "<", "lbl", ".", "end_seconds", ":", "if", "X", "is", "None", ":", "X", "=", "data", "[", "i", ",", ":", "]", "else", ":", "X", "=", "np", ".", "vstack", "(", "(", "X", ",", "data", "[", "i", ",", ":", "]", ")", ")", "Y", ".", "append", "(", "lbl", ".", "label", ")", "new_timestamps", ".", "append", "(", "current_new_timestamp", ")", "current_new_timestamp", "+=", "timestamp_step", "if", "lbl", ".", "label", "not", "in", "classes", ":", "classes", ".", "append", "(", "lbl", ".", "label", ")", "return", "X", ",", "Y", ",", "classes", ",", "new_timestamps" ]

[ "DOESN", "T", "work", "with", "OVERLAPPING", "labels" ]

[ "def", "scope_logger", "(", "cls", ")", ":", "cls", ".", "log", "=", "logging", ".", "getLogger", "(", "'{0}.{1}'", ".", "format", "(", "cls", ".", "__module__", ",", "cls", ".", "__name__", ")", ")", "return", "cls" ]

[ "Class", "decorator", "for", "adding", "a", "class", "local", "logger" ]

[ "def", "run", "(", "self", ")", ":", "self", ".", "_finished", ".", "clear", "(", ")", "for", "line", "in", "iter", "(", "self", ".", "pipeReader", ".", "readline", ",", "''", ")", ":", "logging", ".", "log", "(", "self", ".", "level", ",", "line", ".", "strip", "(", "'\\n'", ")", ")", "self", ".", "pipeReader", ".", "close", "(", ")", "self", ".", "_finished", ".", "set", "(", ")" ]

[ "Run", "the", "thread", "logging", "everything", "." ]

[ "def", "load", "(", "self", ",", "source", ",", "filepath", "=", "None", ")", ":", "# Set _path if source is a file-like object", "try", ":", "self", ".", "_path", "=", "source", ".", "name", "except", "AttributeError", ":", "self", ".", "_path", "=", "filepath", "# Get source content either it's a string or a file-like object", "try", ":", "source_content", "=", "source", ".", "read", "(", ")", "except", "AttributeError", ":", "source_content", "=", "source", "# Parse and serialize given source", "parser", "=", "TinycssSourceParser", "(", ")", "self", ".", "_datas", "=", "parser", ".", "parse", "(", "source_content", ")", "serializer", "=", "ManifestSerializer", "(", ")", "references", "=", "serializer", ".", "serialize", "(", "self", ".", "_datas", ")", "# Copy serialized metas", "self", ".", "metas", "=", "serializer", ".", "_metas", "# Set every enabled rule as object attribute", "for", "k", ",", "v", "in", "references", ".", "items", "(", ")", ":", "self", ".", "set_rule", "(", "k", ",", "v", ")", "return", "self", ".", "_datas" ]

[ "Load", "source", "as", "manifest", "attributes" ]

[ "def", "set_rule", "(", "self", ",", "name", ",", "properties", ")", ":", "self", ".", "_rule_attrs", ".", "append", "(", "name", ")", "setattr", "(", "self", ",", "name", ",", "properties", ")" ]

[ "Set", "a", "rules", "as", "object", "attribute", "." ]

[ "def", "remove_rule", "(", "self", ",", "name", ")", ":", "self", ".", "_rule_attrs", ".", "remove", "(", "name", ")", "delattr", "(", "self", ",", "name", ")" ]

[ "Remove", "a", "rule", "from", "attributes", "." ]

[ "def", "to_json", "(", "self", ",", "indent", "=", "4", ")", ":", "agregate", "=", "{", "'metas'", ":", "self", ".", "metas", ",", "}", "agregate", ".", "update", "(", "{", "k", ":", "getattr", "(", "self", ",", "k", ")", "for", "k", "in", "self", ".", "_rule_attrs", "}", ")", "return", "json", ".", "dumps", "(", "agregate", ",", "indent", "=", "indent", ")" ]

[ "Serialize", "metas", "and", "reference", "attributes", "to", "a", "JSON", "string", "." ]

[ "def", "send", "(", "self", ",", "to", ",", "cc", ",", "subject", ",", "body", ",", "atts", "=", "None", ",", "delete", "=", "False", ")", ":", "email_cnt", "=", "MIMEMultipart", "(", ")", "email_cnt", "[", "'From'", "]", "=", "Header", "(", "self", ".", "smtp_user", ",", "CHARSET_ENCODING", ")", "email_cnt", "[", "'To'", "]", "=", "Header", "(", "';'", ".", "join", "(", "to", ")", ",", "CHARSET_ENCODING", ")", "email_cnt", "[", "'Cc'", "]", "=", "Header", "(", "';'", ".", "join", "(", "cc", ")", ",", "CHARSET_ENCODING", ")", "email_cnt", "[", "'Subject'", "]", "=", "Header", "(", "subject", ",", "CHARSET_ENCODING", ")", "email_cnt", "[", "'Date'", "]", "=", "formatdate", "(", ")", "email_cnt", ".", "attach", "(", "MIMEText", "(", "body", ",", "'html'", ",", "CHARSET_ENCODING", ")", ")", "self", ".", "__add_att__", "(", "email_cnt", ",", "atts", ",", "delete", ")", "try", ":", "self", ".", "__login__", "(", ")", "self", ".", "smtp_conn", ".", "sendmail", "(", "self", ".", "smtp_user", ",", "to", "+", "cc", ",", "email_cnt", ".", "as_string", "(", ")", ")", "with_att_msg", "=", "'Empty'", "if", "atts", ":", "for", "i", ",", "att", "in", "enumerate", "(", "atts", ")", ":", "atts", "[", "i", "]", "=", "att", "[", "att", ".", "startswith", "(", "'/'", ")", "+", "1", ":", "]", "with_att_msg", "=", "','", ".", "join", "(", "atts", ")", "'''Flush memory\n '''", "atts", "[", ":", "]", "=", "[", "]", "logger", ".", "info", "(", "'Send email[%s] success.'", ",", "subject", ")", "logger", ".", "info", "(", "'To users: %s.'", ",", "','", ".", "join", "(", "to", "+", "cc", ")", ")", "logger", ".", "info", "(", "'With attachments: %s.'", ",", "with_att_msg", ")", "except", "Exception", "as", "e", ":", "raise", "SendEmailException", "(", "\"Send email[%s] failed!!! Case: %s\"", "%", "(", "subject", ",", "str", "(", "e", ")", ")", ")" ]

[ "Send", "an", "email", "action", "." ]

[ "def", "restrict", "(", "self", ",", "addr", ")", ":", "# Remove the address from the set", "ip_addr", "=", "_parse_ip", "(", "addr", ")", "if", "ip_addr", "is", "None", ":", "LOG", ".", "warn", "(", "\"Cannot restrict address %r from proxy %s: \"", "\"invalid address\"", "%", "(", "addr", ",", "self", ".", "address", ")", ")", "else", ":", "self", ".", "excluded", ".", "add", "(", "addr", ")" ]

[ "Drop", "an", "address", "from", "the", "set", "of", "addresses", "this", "proxy", "is", "permitted", "to", "introduce", "." ]

[ "def", "accept", "(", "self", ",", "addr", ")", ":", "# Add the address to the set", "ip_addr", "=", "_parse_ip", "(", "addr", ")", "if", "ip_addr", "is", "None", ":", "LOG", ".", "warn", "(", "\"Cannot add address %r to proxy %s: \"", "\"invalid address\"", "%", "(", "addr", ",", "self", ".", "address", ")", ")", "else", ":", "self", ".", "accepted", ".", "add", "(", "addr", ")" ]

[ "Add", "an", "address", "to", "the", "set", "of", "addresses", "this", "proxy", "is", "permitted", "to", "introduce", "." ]

[ "def", "validate", "(", "self", ",", "proxy_ip", ",", "client_ip", ")", ":", "# First, look up the proxy", "if", "self", ".", "pseudo_proxy", ":", "proxy", "=", "self", ".", "pseudo_proxy", "elif", "proxy_ip", "not", "in", "self", ".", "proxies", ":", "return", "False", "else", ":", "proxy", "=", "self", ".", "proxies", "[", "proxy_ip", "]", "# Now, verify that the client is valid", "return", "client_ip", "in", "proxy" ]

[ "Looks", "up", "the", "proxy", "identified", "by", "its", "IP", "then", "verifies", "that", "the", "given", "client", "IP", "may", "be", "introduced", "by", "that", "proxy", "." ]

[ "def", "requires_auth", "(", "func", ")", ":", "@", "six", ".", "wraps", "(", "func", ")", "def", "wrapper", "(", "self", ",", "*", "args", ",", "*", "*", "kwargs", ")", ":", "if", "self", ".", "token_expired", ":", "self", ".", "authenticate", "(", ")", "return", "func", "(", "self", ",", "*", "args", ",", "*", "*", "kwargs", ")", "return", "wrapper" ]

[ "Handle", "authentication", "checks", "." ]

[ "def", "headers", "(", "self", ")", ":", "self", ".", "_headers", ".", "update", "(", "*", "*", "{", "'Accept-Language'", ":", "self", ".", "language", "}", ")", "if", "self", ".", "__token", ":", "self", ".", "_headers", ".", "update", "(", "*", "*", "{", "'Authorization'", ":", "'Bearer %s'", "%", "self", ".", "__token", "}", ")", "return", "self", ".", "_headers" ]

[ "Provide", "access", "to", "updated", "headers", "." ]

[ "def", "token_expired", "(", "self", ")", ":", "if", "self", ".", "_token_timer", "is", "None", ":", "return", "True", "return", "timeutil", ".", "is_newer_than", "(", "self", ".", "_token_timer", ",", "timeutil", ".", "ONE_HOUR", ")" ]

[ "Provide", "access", "to", "flag", "indicating", "if", "token", "has", "expired", "." ]

[ "def", "session", "(", "self", ")", ":", "if", "self", ".", "_session", "is", "None", ":", "self", ".", "_session", "=", "cachecontrol", ".", "CacheControl", "(", "requests", ".", "Session", "(", ")", ",", "cache", "=", "caches", ".", "FileCache", "(", "'.tvdb_cache'", ")", ")", "return", "self", ".", "_session" ]

[ "Provide", "access", "to", "request", "session", "with", "local", "cache", "enabled", "." ]

[ "def", "_exec_request", "(", "self", ",", "service", ",", "method", "=", "None", ",", "path_args", "=", "None", ",", "data", "=", "None", ",", "params", "=", "None", ")", ":", "if", "path_args", "is", "None", ":", "path_args", "=", "[", "]", "req", "=", "{", "'method'", ":", "method", "or", "'get'", ",", "'url'", ":", "'/'", ".", "join", "(", "str", "(", "a", ")", ".", "strip", "(", "'/'", ")", "for", "a", "in", "[", "cfg", ".", "CONF", ".", "tvdb", ".", "service_url", ",", "service", "]", "+", "path_args", ")", ",", "'data'", ":", "json", ".", "dumps", "(", "data", ")", "if", "data", "else", "None", ",", "'headers'", ":", "self", ".", "headers", ",", "'params'", ":", "params", ",", "'verify'", ":", "cfg", ".", "CONF", ".", "tvdb", ".", "verify_ssl_certs", ",", "}", "LOG", ".", "debug", "(", "'executing request (%s %s)'", ",", "req", "[", "'method'", "]", ",", "req", "[", "'url'", "]", ")", "resp", "=", "self", ".", "session", ".", "request", "(", "*", "*", "req", ")", "resp", ".", "raise_for_status", "(", ")", "return", "resp", ".", "json", "(", ")", "if", "resp", ".", "text", "else", "resp", ".", "text" ]

[ "Execute", "request", "." ]

[ "def", "authenticate", "(", "self", ")", ":", "if", "self", ".", "__token", ":", "try", ":", "resp", "=", "self", ".", "_refresh_token", "(", ")", "except", "exceptions", ".", "TVDBRequestException", "as", "err", ":", "# if a 401 is the cause try to login", "if", "getattr", "(", "err", ".", "response", ",", "'status_code'", ",", "0", ")", "==", "401", ":", "resp", "=", "self", ".", "_login", "(", ")", "else", ":", "raise", "else", ":", "resp", "=", "self", ".", "_login", "(", ")", "self", ".", "__token", "=", "resp", ".", "get", "(", "'token'", ")", "self", ".", "_token_timer", "=", "timeutil", ".", "utcnow", "(", ")" ]

[ "Aquire", "authorization", "token", "for", "using", "thetvdb", "apis", "." ]

[ "def", "search_series", "(", "self", ",", "*", "*", "kwargs", ")", ":", "params", "=", "{", "}", "for", "arg", ",", "val", "in", "six", ".", "iteritems", "(", "kwargs", ")", ":", "if", "arg", "in", "SERIES_BY", ":", "params", "[", "arg", "]", "=", "val", "resp", "=", "self", ".", "_exec_request", "(", "'search'", ",", "path_args", "=", "[", "'series'", "]", ",", "params", "=", "params", ")", "if", "cfg", ".", "CONF", ".", "tvdb", ".", "select_first", ":", "return", "resp", "[", "'data'", "]", "[", "0", "]", "return", "resp", "[", "'data'", "]" ]

[ "Provide", "the", "ability", "to", "search", "for", "a", "series", "." ]

[ "def", "get_episodes", "(", "self", ",", "series_id", ",", "*", "*", "kwargs", ")", ":", "params", "=", "{", "'page'", ":", "1", "}", "for", "arg", ",", "val", "in", "six", ".", "iteritems", "(", "kwargs", ")", ":", "if", "arg", "in", "EPISODES_BY", ":", "params", "[", "arg", "]", "=", "val", "return", "self", ".", "_exec_request", "(", "'series'", ",", "path_args", "=", "[", "series_id", ",", "'episodes'", ",", "'query'", "]", ",", "params", "=", "params", ")", "[", "'data'", "]" ]

[ "All", "episodes", "for", "a", "given", "series", "." ]

[ "def", "intersectingPoint", "(", "self", ",", "p", ")", ":", "# perfect match", "if", "p", "==", "self", ".", "data", ".", "mid", ":", "return", "self", ".", "data", ".", "ends", "if", "p", ">", "self", ".", "data", ".", "mid", ":", "# we know all intervals in self.data begin before p (if they began after", "# p, they would have not included mid) we just need to find those that", "# end after p", "endAfterP", "=", "[", "r", "for", "r", "in", "self", ".", "data", ".", "ends", "if", "(", "r", ".", "end", ">=", "p", "and", "not", "self", ".", "openEnded", ")", "or", "(", "r", ".", "end", ">", "p", "and", "self", ".", "openEnded", ")", "]", "if", "self", ".", "right", "is", "not", "None", ":", "endAfterP", ".", "extend", "(", "self", ".", "right", ".", "intersectingPoint", "(", "p", ")", ")", "return", "endAfterP", "if", "p", "<", "self", ".", "data", ".", "mid", ":", "# we know all intervals in self.data end after p (if they ended before p,", "# they would have not included mid) we just need to find those that start", "# before p", "startBeforeP", "=", "[", "r", "for", "r", "in", "self", ".", "data", ".", "starts", "if", "r", ".", "start", "<=", "p", "]", "if", "self", ".", "left", "is", "not", "None", ":", "startBeforeP", ".", "extend", "(", "self", ".", "left", ".", "intersectingPoint", "(", "p", ")", ")", "return", "startBeforeP" ]

[ "given", "a", "point", "get", "intervals", "in", "the", "tree", "that", "are", "intersected", "." ]

[ "def", "intersectingInterval", "(", "self", ",", "start", ",", "end", ")", ":", "# find all intervals in this node that intersect start and end", "l", "=", "[", "]", "for", "x", "in", "self", ".", "data", ".", "starts", ":", "xStartsAfterInterval", "=", "(", "x", ".", "start", ">", "end", "and", "not", "self", ".", "openEnded", ")", "or", "(", "x", ".", "start", ">=", "end", "and", "self", ".", "openEnded", ")", "xEndsBeforeInterval", "=", "(", "x", ".", "end", "<", "start", "and", "not", "self", ".", "openEnded", ")", "or", "(", "x", ".", "end", "<=", "start", "and", "self", ".", "openEnded", ")", "if", "(", "(", "not", "xStartsAfterInterval", ")", "and", "(", "not", "xEndsBeforeInterval", ")", ")", ":", "l", ".", "append", "(", "x", ")", "# process left subtree (if we have one) if the requested interval begins", "# before mid", "if", "self", ".", "left", "is", "not", "None", "and", "start", "<=", "self", ".", "data", ".", "mid", ":", "l", "+=", "self", ".", "left", ".", "intersectingInterval", "(", "start", ",", "end", ")", "# process right subtree (if we have one) if the requested interval ends", "# after mid", "if", "self", ".", "right", "is", "not", "None", "and", "end", ">=", "self", ".", "data", ".", "mid", ":", "l", "+=", "self", ".", "right", ".", "intersectingInterval", "(", "start", ",", "end", ")", "return", "l" ]

[ "given", "an", "interval", "get", "intervals", "in", "the", "tree", "that", "are", "intersected", "." ]

[ "def", "intersectingIntervalIterator", "(", "self", ",", "start", ",", "end", ")", ":", "items", "=", "self", ".", "intersectingInterval", "(", "start", ",", "end", ")", "items", ".", "sort", "(", "key", "=", "lambda", "x", ":", "x", ".", "start", ")", "for", "item", "in", "items", ":", "yield", "item" ]

[ "Get", "an", "iterator", "which", "will", "iterate", "over", "those", "objects", "in", "the", "tree", "which", "intersect", "the", "given", "interval", "-", "sorted", "in", "order", "of", "start", "index" ]

[ "def", "initiate_tasks", "(", "self", ")", ":", "self", ".", "tasks_classes", "=", "TaskLoader", "(", ")", ".", "load_tasks", "(", "paths", "=", "self", ".", "configuration", "[", "Configuration", ".", "ALGORITHM", "]", "[", "Configuration", ".", "TASKS", "]", "[", "Configuration", ".", "PATHS", "]", ")" ]

[ "Loads", "all", "tasks", "using", "TaskLoader", "from", "respective", "configuration", "option" ]

[ "def", "instantiate_tasks", "(", "self", ")", ":", "self", ".", "tasks_instances", "=", "{", "}", "for", "task_name", ",", "task_class", "in", "self", ".", "tasks_classes", ".", "items", "(", ")", ":", "try", ":", "self", ".", "tasks_instances", "[", "task_name", "]", "=", "task_class", "(", ")", "except", "Exception", "as", "ex", ":", "if", "not", "self", ".", "configuration", "[", "Configuration", ".", "ALGORITHM", "]", "[", "Configuration", ".", "IOSF", "]", ":", "raise", "GOSTaskException", "(", "\"An exception happened during the task instantiation.\"", "\"{exception}\"", ".", "format", "(", "exception", "=", "ex", ")", ")" ]

[ "All", "loaded", "tasks", "are", "initialized", ".", "Depending", "on", "configuration", "fails", "in", "such", "instantiations", "may", "be", "silent" ]

[ "def", "_have", "(", "self", ",", "name", "=", "None", ")", ":", "if", "name", "is", "None", ":", "return", "(", "(", "k", ",", "v", ")", "for", "k", ",", "v", "in", "self", ".", "env", ".", "items", "(", ")", "if", "k", ".", "startswith", "(", "'HAVE_'", ")", ")", "return", "self", ".", "env", ".", "get", "(", "'HAVE_'", "+", "self", ".", "env_key", "(", "name", ")", ")", "==", "True" ]

[ "Check", "if", "a", "configure", "flag", "is", "set", "." ]

[ "def", "_lib", "(", "self", ",", "name", ",", "only_if_have", "=", "False", ")", ":", "emit", "=", "True", "if", "only_if_have", ":", "emit", "=", "self", ".", "env", ".", "get", "(", "'HAVE_LIB'", "+", "self", ".", "env_key", "(", "name", ")", ")", "if", "emit", ":", "return", "'-l'", "+", "name", "return", "''" ]

[ "Specify", "a", "linker", "library", "." ]

[ "def", "_with", "(", "self", ",", "option", "=", "None", ")", ":", "if", "option", "is", "None", ":", "return", "(", "(", "k", ",", "v", ")", "for", "k", ",", "v", "in", "self", ".", "env", ".", "items", "(", ")", "if", "k", ".", "startswith", "(", "'WITH_'", ")", ")", "return", "self", ".", "env", ".", "get", "(", "'WITH_'", "+", "option", ".", "upper", "(", ")", ")", "==", "True" ]

[ "Check", "if", "a", "build", "option", "is", "enabled", "." ]

[ "def", "set_codes", "(", "self", ",", "codes", ",", "reject", "=", "False", ")", ":", "self", ".", "codes", "=", "set", "(", "codes", ")", "self", ".", "reject", "=", "reject" ]

[ "Set", "the", "accepted", "or", "rejected", "codes", "codes", "list", "." ]

[ "def", "accept", "(", "self", ",", "code", ")", ":", "if", "code", "in", "self", ".", "codes", ":", "return", "not", "self", ".", "reject", "return", "self", ".", "reject" ]

[ "Determine", "whether", "to", "accept", "the", "given", "code", "." ]

[ "def", "_needescape", "(", "c", ")", ":", "return", "not", "ascii", ".", "isprint", "(", "c", ")", "or", "c", "==", "'\"'", "or", "c", "==", "'\\\\'", "or", "ascii", ".", "isctrl", "(", "c", ")" ]

[ "Return", "True", "if", "character", "needs", "escaping", "else", "False", "." ]

[ "def", "escape", "(", "cls", ",", "string", ")", ":", "return", "''", ".", "join", "(", "[", "cls", ".", "_escapes", "[", "c", "]", "if", "cls", ".", "_needescape", "(", "c", ")", "else", "c", "for", "c", "in", "string", ".", "encode", "(", "'utf8'", ")", "]", ")" ]

[ "Utility", "method", "to", "produce", "an", "escaped", "version", "of", "a", "given", "string", "." ]

[ "def", "submit", "(", "self", ")", ":", "u", "=", "urlparse", "(", "self", ".", "url", ")", "if", "not", "self", ".", "action", ":", "self", ".", "action", "=", "self", ".", "url", "elif", "self", ".", "action", "==", "u", ".", "path", ":", "self", ".", "action", "=", "self", ".", "url", "else", ":", "if", "not", "u", ".", "netloc", "in", "self", ".", "action", ":", "path", "=", "\"/\"", ".", "join", "(", "u", ".", "path", ".", "split", "(", "\"/\"", ")", "[", "1", ":", "-", "1", "]", ")", "if", "self", ".", "action", ".", "startswith", "(", "\"/\"", ")", ":", "path", "=", "path", "+", "self", ".", "action", "else", ":", "path", "=", "path", "+", "\"/\"", "+", "self", ".", "action", "self", ".", "action", "=", "\"http://\"", "+", "u", ".", "netloc", "+", "\"/\"", "+", "path", "return", "self", ".", "usr", ".", "getPage", "(", "self", ".", "action", ",", "self", ".", "items", ",", "{", "'Referer'", ":", "self", ".", "url", "}", ",", "self", ".", "usePin", ")" ]

[ "Posts", "the", "form", "s", "data", "and", "returns", "the", "resulting", "Page", "Returns", "Page", "-", "The", "resulting", "page" ]

[ "def", "compute_hash", "(", "attributes", ",", "ignored_attributes", "=", "None", ")", ":", "ignored_attributes", "=", "list", "(", "ignored_attributes", ")", "if", "ignored_attributes", "else", "[", "]", "tuple_attributes", "=", "_convert", "(", "attributes", ".", "copy", "(", ")", ",", "ignored_attributes", ")", "hasher", "=", "hashlib", ".", "sha256", "(", "str", "(", "tuple_attributes", ")", ".", "encode", "(", "'utf-8'", ",", "errors", "=", "'ignore'", ")", ")", "return", "hasher", ".", "hexdigest", "(", ")" ]

[ "Computes", "a", "hash", "code", "for", "the", "given", "dictionary", "that", "is", "safe", "for", "persistence", "round", "trips" ]

[ "def", "SimpleRowColumn", "(", "field", ",", "*", "args", ",", "*", "*", "kwargs", ")", ":", "if", "isinstance", "(", "field", ",", "basestring", ")", ":", "field", "=", "Field", "(", "field", ",", "*", "args", ",", "*", "*", "kwargs", ")", "return", "Row", "(", "Column", "(", "field", ")", ",", ")" ]

[ "Shortcut", "for", "simple", "row", "with", "only", "a", "full", "column" ]

[ "def", "save", "(", "self", ",", "commit", "=", "True", ")", ":", "contact", "=", "super", "(", "ContactFormBase", ",", "self", ")", ".", "save", "(", ")", "context", "=", "{", "'contact'", ":", "contact", "}", "context", ".", "update", "(", "get_site_metas", "(", ")", ")", "subject", "=", "''", ".", "join", "(", "render_to_string", "(", "self", ".", "mail_subject_template", ",", "context", ")", ".", "splitlines", "(", ")", ")", "content", "=", "render_to_string", "(", "self", ".", "mail_content_template", ",", "context", ")", "send_mail", "(", "subject", ",", "content", ",", "settings", ".", "DEFAULT_FROM_EMAIL", ",", "settings", ".", "CONTACT_FORM_TO", ",", "fail_silently", "=", "not", "settings", ".", "DEBUG", ")", "return", "contact" ]

[ "Save", "and", "send" ]

[ "def", "bark_filter", "(", "global_conf", ",", "*", "*", "local_conf", ")", ":", "# First, parse the configuration", "conf_file", "=", "None", "sections", "=", "{", "}", "for", "key", ",", "value", "in", "local_conf", ".", "items", "(", ")", ":", "# 'config' key causes a load of a configuration file; settings", "# in the local_conf will override settings in the", "# configuration file, however", "if", "key", "==", "'config'", ":", "conf_file", "=", "value", "elif", "'.'", "in", "key", ":", "sect", ",", "_sep", ",", "opt", "=", "key", ".", "partition", "(", "'.'", ")", "sect_dict", "=", "sections", ".", "setdefault", "(", "sect", ",", "{", "}", ")", "sect_dict", "[", "opt", "]", "=", "value", "# note: a string", "# Now that we've loaded local_conf, process conf_file (if any)", "if", "conf_file", ":", "cp", "=", "ConfigParser", ".", "SafeConfigParser", "(", ")", "cp", ".", "read", "(", "[", "conf_file", "]", ")", "for", "sect", "in", "cp", ".", "sections", "(", ")", ":", "for", "opt", ",", "value", "in", "cp", ".", "options", "(", "sect", ")", ":", "sect_dict", "=", "sections", ".", "setdefault", "(", "sect", ",", "{", "}", ")", "# By using setdefault(), we allow local_conf to", "# override the configuration file", "sect_dict", ".", "setdefault", "(", "opt", ",", "value", ")", "# OK, the configuration is all read; next step is to turn the", "# configuration into logging handlers", "handlers", "=", "{", "}", "proxies", "=", "None", "for", "sect", ",", "sect_dict", "in", "sections", ".", "items", "(", ")", ":", "if", "sect", "==", "'proxies'", ":", "# Reserved for proxy configuration", "try", ":", "proxies", "=", "bark", ".", "proxy", ".", "ProxyConfig", "(", "sect_dict", ")", "except", "KeyError", "as", "exc", ":", "LOG", ".", "warn", "(", "\"Cannot configure proxy handling: option %s is \"", "\"missing from the proxy configuration\"", "%", "exc", ")", "continue", "# Pragma: nocover", "# First, determine the logging format", "try", ":", "format", "=", "bark", ".", "format", ".", "Format", ".", "parse", "(", "sect_dict", ".", "pop", "(", "'format'", ")", ")", "except", "KeyError", ":", "LOG", ".", "warn", "(", "\"No format specified for log %r; skipping.\"", "%", "sect", ")", "continue", "# Next, determine the handler type", "handle_type", "=", "sect_dict", ".", "pop", "(", "'type'", ",", "'file'", ")", "# Now, let's construct a handler; this will be a callable", "# taking the formatted message to log", "try", ":", "handler", "=", "bark", ".", "handlers", ".", "get_handler", "(", "handle_type", ",", "sect", ",", "sect_dict", ")", "except", "Exception", "as", "exc", ":", "LOG", ".", "warn", "(", "\"Cannot load handler of type %r for log %r: %s\"", "%", "(", "handle_type", ",", "sect", ",", "exc", ")", ")", "continue", "# We now have a handler and a format; bundle them up", "handlers", "[", "sect", "]", "=", "(", "format", ",", "handler", ")", "# Construct the wrapper which is going to instantiate the", "# middleware", "def", "wrapper", "(", "app", ")", ":", "return", "BarkMiddleware", "(", "app", ",", "handlers", ",", "proxies", ")", "return", "wrapper" ]

[ "Factory", "function", "for", "Bark", ".", "Returns", "a", "function", "which", "when", "passed", "the", "application", "returns", "an", "instance", "of", "BarkMiddleware", "." ]

[ "def", "blog_post_feed", "(", "request", ",", "format", ",", "*", "*", "kwargs", ")", ":", "try", ":", "return", "{", "\"rss\"", ":", "PostsRSS", ",", "\"atom\"", ":", "PostsAtom", "}", "[", "format", "]", "(", "*", "*", "kwargs", ")", "(", "request", ")", "except", "KeyError", ":", "raise", "Http404", "(", ")" ]

[ "Blog", "posts", "feeds", "-", "maps", "format", "to", "the", "correct", "feed", "view", "." ]

[ "def", "connect", "(", "self", ")", ":", "self", ".", "connection", "=", "Connection", "(", "self", ".", "broker_url", ")", "e", "=", "Exchange", "(", "'mease'", ",", "type", "=", "'fanout'", ",", "durable", "=", "False", ",", "delivery_mode", "=", "1", ")", "self", ".", "exchange", "=", "e", "(", "self", ".", "connection", ".", "default_channel", ")", "self", ".", "exchange", ".", "declare", "(", ")" ]

[ "Connects", "to", "RabbitMQ" ]

[ "def", "publish", "(", "self", ",", "message_type", ",", "client_id", ",", "client_storage", ",", "*", "args", ",", "*", "*", "kwargs", ")", ":", "if", "self", ".", "connection", ".", "connected", ":", "message", "=", "self", ".", "exchange", ".", "Message", "(", "self", ".", "pack", "(", "message_type", ",", "client_id", ",", "client_storage", ",", "args", ",", "kwargs", ")", ")", "self", ".", "exchange", ".", "publish", "(", "message", ",", "routing_key", "=", "''", ")" ]

[ "Publishes", "a", "message", "Uses", "self", ".", "pack", "instead", "of", "msgpack", "serializer", "on", "kombu", "for", "backend", "consistency" ]

[ "def", "connect", "(", "self", ")", ":", "logger", ".", "info", "(", "\"Connecting to RabbitMQ on {broker_url}...\"", ".", "format", "(", "broker_url", "=", "self", ".", "broker_url", ")", ")", "super", "(", "RabbitMQSubscriber", ",", "self", ")", ".", "connect", "(", ")", "q", "=", "Queue", "(", "exchange", "=", "self", ".", "exchange", ",", "exclusive", "=", "True", ",", "durable", "=", "False", ")", "self", ".", "queue", "=", "q", "(", "self", ".", "connection", ".", "default_channel", ")", "self", ".", "queue", ".", "declare", "(", ")", "self", ".", "thread", "=", "Thread", "(", "target", "=", "self", ".", "listen", ")", "self", ".", "thread", ".", "setDaemon", "(", "True", ")", "self", ".", "thread", ".", "start", "(", ")" ]

[ "Connects", "to", "RabbitMQ", "and", "starts", "listening" ]

[ "def", "listen", "(", "self", ")", ":", "with", "Consumer", "(", "self", ".", "connection", ",", "queues", "=", "self", ".", "queue", ",", "on_message", "=", "self", ".", "on_message", ",", "auto_declare", "=", "False", ")", ":", "for", "_", "in", "eventloop", "(", "self", ".", "connection", ",", "timeout", "=", "1", ",", "ignore_timeouts", "=", "True", ")", ":", "pass" ]

[ "Listens", "to", "messages" ]

[ "def", "main_loop", "(", "self", ")", ":", "while", "True", ":", "for", "e", "in", "pygame", ".", "event", ".", "get", "(", ")", ":", "self", ".", "handle_event", "(", "e", ")", "self", ".", "step", "(", ")", "pygame", ".", "time", ".", "wait", "(", "5", ")" ]

[ "Runs", "the", "main", "game", "loop", "." ]

[ "def", "quit", "(", "self", ",", "event", ")", ":", "self", ".", "logger", ".", "info", "(", "\"Quitting.\"", ")", "self", ".", "on_exit", "(", ")", "sys", ".", "exit", "(", ")" ]

[ "Quit", "the", "game", "." ]

[ "def", "setCredentials", "(", "self", ",", "user", ",", "password", ")", ":", "self", ".", "_checkUserAndPass", "(", "user", ",", "password", ")", "self", ".", "user", "=", "user", "self", ".", "password", "=", "password" ]

[ "!", "Set", "authentication", "credentials", "." ]

[ "def", "get_setting_with_envfallback", "(", "setting", ",", "default", "=", "None", ",", "typecast", "=", "None", ")", ":", "try", ":", "from", "django", ".", "conf", "import", "settings", "except", "ImportError", ":", "return", "default", "else", ":", "fallback", "=", "getattr", "(", "settings", ",", "setting", ",", "default", ")", "value", "=", "os", ".", "environ", ".", "get", "(", "setting", ",", "fallback", ")", "if", "typecast", ":", "value", "=", "typecast", "(", "value", ")", "return", "value" ]

[ "Get", "the", "given", "setting", "and", "fall", "back", "to", "the", "default", "of", "not", "found", "in", "django", ".", "conf", ".", "settings", "or", "os", ".", "environ", "." ]

[ "def", "add_file_locations", "(", "self", ",", "file_locations", "=", "[", "]", ")", ":", "if", "not", "hasattr", "(", "self", ",", "'__file_locations__'", ")", ":", "self", ".", "__file_locations__", "=", "copy", ".", "copy", "(", "file_locations", ")", "else", ":", "self", ".", "__file_locations__", "+=", "copy", ".", "copy", "(", "file_locations", ")" ]

[ "Adds", "a", "list", "of", "file", "locations", "to", "the", "current", "list" ]

[ "def", "reset", "(", "self", ",", "*", "*", "kwargs", ")", ":", "self", ".", "drop_all", "(", "*", "*", "kwargs", ")", "file_locations", "=", "self", ".", "__file_locations__", "self", ".", "__file_locations__", "=", "[", "]", "self", ".", "load", "(", "file_locations", ",", "*", "*", "kwargs", ")" ]

[ "Reset", "the", "triplestore", "with", "all", "of", "the", "data" ]

[ "def", "drop_all", "(", "self", ",", "*", "*", "kwargs", ")", ":", "conn", "=", "self", ".", "__get_conn__", "(", "*", "*", "kwargs", ")", "conn", ".", "update_query", "(", "\"DROP ALL\"", ")", "self", ".", "loaded", "=", "[", "]", "self", ".", "loaded_times", "=", "{", "}" ]

[ "Drops", "all", "definitions" ]

[ "def", "load_file", "(", "self", ",", "filepath", ",", "*", "*", "kwargs", ")", ":", "log", ".", "setLevel", "(", "kwargs", ".", "get", "(", "\"log_level\"", ",", "self", ".", "log_level", ")", ")", "filename", "=", "os", ".", "path", ".", "split", "(", "filepath", ")", "[", "-", "1", "]", "if", "filename", "in", "self", ".", "loaded", ":", "if", "self", ".", "loaded_times", ".", "get", "(", "filename", ",", "datetime", ".", "datetime", "(", "2001", ",", "1", ",", "1", ")", ")", ".", "timestamp", "(", ")", "<", "os", ".", "path", ".", "getmtime", "(", "filepath", ")", ":", "self", ".", "drop_file", "(", "filename", ",", "*", "*", "kwargs", ")", "else", ":", "return", "conn", "=", "self", ".", "__get_conn__", "(", "*", "*", "kwargs", ")", "conn", ".", "load_data", "(", "graph", "=", "getattr", "(", "__NSM__", ".", "kdr", ",", "filename", ")", ".", "clean_uri", ",", "data", "=", "filepath", ",", "# log_level=logging.DEBUG,", "is_file", "=", "True", ")", "self", ".", "__update_time__", "(", "filename", ",", "*", "*", "kwargs", ")", "log", ".", "warning", "(", "\"\\n\\tfile: '%s' loaded\\n\\tconn: '%s'\\n\\tpath: %s\"", ",", "filename", ",", "conn", ",", "filepath", ")", "self", ".", "loaded", ".", "append", "(", "filename", ")" ]

[ "loads", "a", "file", "into", "the", "defintion", "triplestore" ]

[ "def", "load_directory", "(", "self", ",", "directory", ",", "*", "*", "kwargs", ")", ":", "log", ".", "setLevel", "(", "kwargs", ".", "get", "(", "\"log_level\"", ",", "self", ".", "log_level", ")", ")", "conn", "=", "self", ".", "__get_conn__", "(", "*", "*", "kwargs", ")", "file_extensions", "=", "kwargs", ".", "get", "(", "'file_extensions'", ",", "conn", ".", "rdf_formats", ")", "file_list", "=", "list_files", "(", "directory", ",", "file_extensions", ",", "kwargs", ".", "get", "(", "'include_subfolders'", ",", "False", ")", ",", "include_root", "=", "True", ")", "for", "file", "in", "file_list", ":", "self", ".", "load_file", "(", "file", "[", "1", "]", ",", "*", "*", "kwargs", ")", "log", ".", "setLevel", "(", "self", ".", "log_level", ")" ]

[ "loads", "all", "rdf", "files", "in", "a", "directory" ]

[ "def", "read", "(", "fileobj", ",", "version", "=", "None", ")", ":", "magic", "=", "fileobj", ".", "read", "(", "5", ")", "if", "magic", "[", ":", "4", "]", "!=", "b\"TZif\"", ":", "raise", "ValueError", "(", "\"not a zoneinfo file\"", ")", "if", "version", "is", "None", ":", "version", "=", "int", "(", "magic", "[", "4", ":", "]", ")", "if", "magic", "[", "4", "]", "else", "0", "fileobj", ".", "seek", "(", "20", ")", "# Read the counts:", "# [0] - The number of UT/local indicators stored in the file.", "# [1] - The number of standard/wall indicators stored in the file.", "# [2] - The number of leap seconds for which data entries are stored", "# in the file.", "# [3] - The number of transition times for which data entries are", "# stored in the file.", "# [4] - The number of local time types for which data entries are", "# stored in the file (must not be zero).", "# [5] - The number of characters of time zone abbreviation strings", "# stored in the file.", "(", "ttisgmtcnt", ",", "ttisstdcnt", ",", "leapcnt", ",", "timecnt", ",", "typecnt", ",", "charcnt", ")", "=", "_read_counts", "(", "fileobj", ")", "if", "version", ">=", "2", ":", "# Skip to the counts in the second header.", "data_size", "=", "(", "5", "*", "timecnt", "+", "6", "*", "typecnt", "+", "charcnt", "+", "8", "*", "leapcnt", "+", "ttisstdcnt", "+", "ttisgmtcnt", ")", "fileobj", ".", "seek", "(", "data_size", "+", "20", ",", "os", ".", "SEEK_CUR", ")", "# Re-read the counts.", "(", "ttisgmtcnt", ",", "ttisstdcnt", ",", "leapcnt", ",", "timecnt", ",", "typecnt", ",", "charcnt", ")", "=", "_read_counts", "(", "fileobj", ")", "ttfmt", "=", "'q'", "else", ":", "ttfmt", "=", "'i'", "times", "=", "array", "(", "ttfmt", ")", "times", ".", "fromfile", "(", "fileobj", ",", "timecnt", ")", "if", "sys", ".", "byteorder", "!=", "'big'", ":", "times", ".", "byteswap", "(", ")", "type_indices", "=", "array", "(", "'B'", ")", "type_indices", ".", "fromfile", "(", "fileobj", ",", "timecnt", ")", "# Read local time types.", "type_infos", "=", "[", "]", "for", "i", "in", "range", "(", "typecnt", ")", ":", "type_infos", ".", "append", "(", "struct", ".", "unpack", "(", "\">iBB\"", ",", "fileobj", ".", "read", "(", "6", ")", ")", ")", "abbrs", "=", "fileobj", ".", "read", "(", "charcnt", ")", "if", "version", ">", "0", ":", "# Skip to POSIX TZ string", "fileobj", ".", "seek", "(", "12", "*", "leapcnt", "+", "ttisstdcnt", "+", "ttisgmtcnt", ",", "os", ".", "SEEK_CUR", ")", "posix_string", "=", "fileobj", ".", "read", "(", ")", ".", "strip", "(", ")", ".", "decode", "(", "'ascii'", ")", "else", ":", "posix_string", "=", "None", "# Convert type_infos", "for", "i", ",", "(", "gmtoff", ",", "isdst", ",", "abbrind", ")", "in", "enumerate", "(", "type_infos", ")", ":", "abbr", "=", "abbrs", "[", "abbrind", ":", "abbrs", ".", "find", "(", "0", ",", "abbrind", ")", "]", ".", "decode", "(", ")", "type_infos", "[", "i", "]", "=", "(", "gmtoff", ",", "isdst", ",", "abbr", ")", "return", "TZFileData", "(", "version", ",", "type_infos", ",", "times", ",", "type_indices", ",", "posix_string", ")" ]

[ "Read", "tz", "data", "from", "a", "binary", "file", "." ]

[ "def", "convert", "(", "data", ")", ":", "if", "isinstance", "(", "data", ",", "unicode", ")", ":", "return", "data", ".", "encode", "(", "'utf-8'", ")", "elif", "isinstance", "(", "data", ",", "str", ")", ":", "return", "data", "elif", "isinstance", "(", "data", ",", "collections", ".", "Mapping", ")", ":", "return", "dict", "(", "map", "(", "convert", ",", "data", ".", "iteritems", "(", ")", ")", ")", "elif", "isinstance", "(", "data", ",", "collections", ".", "Iterable", ")", ":", "return", "type", "(", "data", ")", "(", "map", "(", "convert", ",", "data", ")", ")", "else", ":", "return", "data" ]

[ "convert", "a", "standalone", "unicode", "string", "or", "unicode", "strings", "in", "a", "mapping", "or", "iterable", "into", "byte", "strings", "." ]

[ "def", "make_fetch_func", "(", "base_url", ",", "async", ",", "*", "*", "kwargs", ")", ":", "if", "async", ":", "client", "=", "AsyncHTTPClient", "(", "force_instance", "=", "True", ",", "defaults", "=", "kwargs", ")", "return", "partial", "(", "async_fetch", ",", "httpclient", "=", "client", ")", "else", ":", "client", "=", "HTTPClient", "(", "force_instance", "=", "True", ",", "defaults", "=", "kwargs", ")", "return", "partial", "(", "sync_fetch", ",", "httpclient", "=", "client", ")" ]

[ "make", "a", "fetch", "function", "based", "on", "conditions", "of", "1", ")", "async", "2", ")", "ssl" ]

[ "def", "_getAuthHeaders", "(", "self", ")", ":", "def", "_handleAuthBody", "(", "body", ")", ":", "self", ".", "msg", "(", "\"_handleAuthBody: %(body)s\"", ",", "body", "=", "body", ")", "try", ":", "body_parsed", "=", "json", ".", "loads", "(", "body", ")", "access_token", "=", "body_parsed", "[", "'access'", "]", "[", "'token'", "]", "tenant_id", "=", "access_token", "[", "'tenant'", "]", "[", "'id'", "]", ".", "encode", "(", "'ascii'", ")", "auth_token", "=", "access_token", "[", "'id'", "]", ".", "encode", "(", "'ascii'", ")", "self", ".", "auth_headers", "[", "\"X-Tenant-Id\"", "]", "=", "tenant_id", "self", ".", "auth_headers", "[", "\"X-Auth-Token\"", "]", "=", "auth_token", "self", ".", "_state", "=", "self", ".", "AUTHENTICATED", "self", ".", "msg", "(", "\"_handleAuthHeaders: found token %(token)s\"", "\" tenant id %(tenant_id)s\"", ",", "token", "=", "self", ".", "auth_headers", "[", "\"X-Auth-Token\"", "]", ",", "tenant_id", "=", "self", ".", "auth_headers", "[", "\"X-Tenant-Id\"", "]", ")", "# Callback all queued auth headers requests", "while", "not", "self", ".", "_headers_requests", ".", "empty", "(", ")", ":", "self", ".", "_headers_requests", ".", "get", "(", ")", ".", "callback", "(", "self", ".", "auth_headers", ")", "except", "ValueError", ":", "# We received a bad response", "return", "fail", "(", "MalformedJSONError", "(", "\"Malformed keystone\"", "\" response received.\"", ")", ")", "def", "_handleAuthResponse", "(", "response", ")", ":", "if", "response", ".", "code", "==", "httplib", ".", "OK", ":", "self", ".", "msg", "(", "\"_handleAuthResponse: %(response)s accepted\"", ",", "response", "=", "response", ")", "body", "=", "Deferred", "(", ")", "response", ".", "deliverBody", "(", "StringIOReceiver", "(", "body", ")", ")", "body", ".", "addCallback", "(", "_handleAuthBody", ")", "return", "body", "else", ":", "self", ".", "msg", "(", "\"_handleAuthResponse: %(response)s rejected\"", ",", "response", "=", "response", ")", "return", "fail", "(", "KeystoneAuthenticationError", "(", "\"Keystone\"", "\" authentication credentials\"", "\" rejected\"", ")", ")", "self", ".", "msg", "(", "\"_getAuthHeaders: state is %(state)s\"", ",", "state", "=", "self", ".", "_state", ")", "if", "self", ".", "_state", "==", "self", ".", "AUTHENTICATED", ":", "# We are authenticated, immediately succeed with the current", "# auth headers", "self", ".", "msg", "(", "\"_getAuthHeaders: succeed with %(headers)s\"", ",", "headers", "=", "self", ".", "auth_headers", ")", "return", "succeed", "(", "self", ".", "auth_headers", ")", "elif", "(", "self", ".", "_state", "==", "self", ".", "NOT_AUTHENTICATED", "or", "self", ".", "_state", "==", "self", ".", "AUTHENTICATING", ")", ":", "# We cannot satisfy the auth header request immediately,", "# put it in a queue", "self", ".", "msg", "(", "\"_getAuthHeaders: defer, place in queue\"", ")", "auth_headers_deferred", "=", "Deferred", "(", ")", "self", ".", "_headers_requests", ".", "put", "(", "auth_headers_deferred", ")", "if", "self", ".", "_state", "==", "self", ".", "NOT_AUTHENTICATED", ":", "self", ".", "msg", "(", "\"_getAuthHeaders: not authenticated, start\"", "\" authentication process\"", ")", "# We are not authenticated, and not in the process of", "# authenticating.", "# Set our state to AUTHENTICATING and begin the", "# authentication process", "self", ".", "_state", "=", "self", ".", "AUTHENTICATING", "d", "=", "self", ".", "agent", ".", "request", "(", "'POST'", ",", "self", ".", "auth_url", ",", "Headers", "(", "{", "\"Content-type\"", ":", "[", "\"application/json\"", "]", "}", ")", ",", "self", ".", "_getAuthRequestBodyProducer", "(", ")", ")", "d", ".", "addCallback", "(", "_handleAuthResponse", ")", "d", ".", "addErrback", "(", "auth_headers_deferred", ".", "errback", ")", "return", "auth_headers_deferred", "else", ":", "# Bad state, fail", "return", "fail", "(", "RuntimeError", "(", "\"Invalid state encountered.\"", ")", ")" ]

[ "Get", "authentication", "headers", ".", "If", "we", "have", "valid", "header", "data", "already", "they", "immediately", "return", "it", ".", "If", "not", "then", "get", "new", "authentication", "data", ".", "If", "we", "are", "currently", "in", "the", "process", "of", "getting", "the", "header", "data", "put", "this", "request", "into", "a", "queue", "to", "be", "handled", "when", "the", "data", "are", "received", "." ]

[ "def", "main", "(", ")", ":", "cmd_args", "=", "TagCubeCLI", ".", "parse_args", "(", ")", "try", ":", "tagcube_cli", "=", "TagCubeCLI", ".", "from_cmd_args", "(", "cmd_args", ")", "except", "ValueError", ",", "ve", ":", "# We get here when there are no credentials configured", "print", "'%s'", "%", "ve", "sys", ".", "exit", "(", "1", ")", "try", ":", "sys", ".", "exit", "(", "tagcube_cli", ".", "run", "(", ")", ")", "except", "ValueError", ",", "ve", ":", "# We get here when the configured credentials had some issue (invalid)", "# or there was some error (such as invalid profile name) with the params", "print", "'%s'", "%", "ve", "sys", ".", "exit", "(", "2", ")" ]

[ "Project", "s", "main", "method", "which", "will", "parse", "the", "command", "line", "arguments", "run", "a", "scan", "using", "the", "TagCubeClient", "and", "exit", "." ]

[ "def", "register", "(", "filetypes", ")", ":", "def", "decorator", "(", "clazz", ")", ":", "for", "ext", "in", "filetypes", ":", "checkers", ".", "setdefault", "(", "ext", ",", "[", "]", ")", ".", "append", "(", "clazz", ")", "return", "clazz", "return", "decorator" ]

[ "Decorator", "to", "register", "a", "class", "as", "a", "checker", "for", "extensions", "." ]

[ "def", "check", "(", "self", ",", "paths", ")", ":", "if", "not", "paths", ":", "return", "(", ")", "cmd_pieces", "=", "[", "self", ".", "tool", "]", "cmd_pieces", ".", "extend", "(", "self", ".", "tool_args", ")", "return", "self", ".", "_check_std", "(", "paths", ",", "cmd_pieces", ")" ]

[ "Return", "list", "of", "error", "dicts", "for", "all", "found", "errors", "in", "paths", "." ]

[ "def", "get_version", "(", "cls", ")", ":", "cmd_pieces", "=", "[", "cls", ".", "tool", ",", "'--version'", "]", "process", "=", "Popen", "(", "cmd_pieces", ",", "stdout", "=", "PIPE", ",", "stderr", "=", "PIPE", ")", "out", ",", "err", "=", "process", ".", "communicate", "(", ")", "if", "err", ":", "return", "''", "else", ":", "return", "out", ".", "splitlines", "(", ")", "[", "0", "]", ".", "strip", "(", ")" ]

[ "Return", "the", "version", "number", "of", "the", "tool", "." ]

[ "def", "_check_std", "(", "self", ",", "paths", ",", "cmd_pieces", ")", ":", "cmd_pieces", ".", "extend", "(", "paths", ")", "process", "=", "Popen", "(", "cmd_pieces", ",", "stdout", "=", "PIPE", ",", "stderr", "=", "PIPE", ")", "out", ",", "err", "=", "process", ".", "communicate", "(", ")", "lines", "=", "out", ".", "strip", "(", ")", ".", "splitlines", "(", ")", "+", "err", ".", "strip", "(", ")", ".", "splitlines", "(", ")", "result", "=", "[", "]", "for", "line", "in", "lines", ":", "match", "=", "self", ".", "tool_err_re", ".", "match", "(", "line", ")", "if", "not", "match", ":", "if", "self", ".", "break_on_tool_re_mismatch", ":", "raise", "ValueError", "(", "'Unexpected `%s` output: %r'", "%", "(", "' '", ".", "join", "(", "cmd_pieces", ")", ",", "paths", ",", "line", ")", ")", "continue", "vals", "=", "match", ".", "groupdict", "(", ")", "# All tools should at least give us line numbers, but only", "# some give column numbers.", "vals", "[", "'lineno'", "]", "=", "int", "(", "vals", "[", "'lineno'", "]", ")", "vals", "[", "'colno'", "]", "=", "int", "(", "vals", "[", "'colno'", "]", ")", "if", "vals", "[", "'colno'", "]", "is", "not", "None", "else", "''", "result", ".", "append", "(", "vals", ")", "return", "result" ]

[ "Run", "cmd", "as", "a", "check", "on", "paths", "." ]

[ "def", "replace", "(", "dict", ",", "line", ")", ":", "words", "=", "line", ".", "split", "(", ")", "new_line", "=", "\"\"", "for", "word", "in", "words", ":", "fst", "=", "word", "[", "0", "]", "last", "=", "word", "[", "-", "1", "]", "# Check if the word ends with a punctuation", "if", "last", "==", "\",\"", "or", "last", "==", "\";\"", "or", "last", "==", "\".\"", ":", "clean_word", "=", "word", "[", "0", ":", "-", "1", "]", "last", "=", "last", "+", "\" \"", "elif", "last", "==", "\"]\"", ":", "clean_word", "=", "word", "[", "0", ":", "-", "1", "]", "else", ":", "clean_word", "=", "word", "last", "=", "\" \"", "# Check if the word starts with \"[\"", "if", "fst", "==", "\"[\"", ":", "clean_word", "=", "clean_word", "[", "1", ":", "]", "else", ":", "clean_word", "=", "clean_word", "fst", "=", "\"\"", "find", "=", "dict", ".", "get", "(", "clean_word", ")", "if", "find", "==", "None", ":", "new_line", "=", "new_line", "+", "fst", "+", "str", "(", "clean_word", ")", "+", "last", "else", ":", "new_line", "=", "new_line", "+", "fst", "+", "str", "(", "find", ")", "+", "last", "return", "new_line" ]

[ "Find", "and", "replace", "the", "special", "words", "according", "to", "the", "dictionary", "." ]

[ "def", "translate", "(", "src_filename", ",", "dest_filename", ",", "dest_lang", ",", "src_lang", "=", "'auto'", ",", "specialwords_filename", "=", "''", ")", ":", "translator", "=", "Translator", "(", ")", "# Initialize translator object", "with", "open", "(", "src_filename", ")", "as", "srcfile", ",", "open", "(", "dest_filename", ",", "'w'", ")", "as", "destfile", ":", "lines", "=", "srcfile", ".", "readlines", "(", ")", "specialwords_dict", "=", "{", "}", "# If special words file exists, place special word mappings into specialwords_dict", "if", "specialwords_filename", "!=", "''", ":", "with", "yaml", ".", "load", "(", "open", "(", "specialwords_filename", ")", ")", "as", "specialwords_fulllist", ":", "# Gets source language if not passed through", "if", "src_lang", "==", "'auto'", ":", "src_lang", "==", "str", "(", "translator", ".", "detect", "(", "lines", "[", "0", "]", ")", ")", "[", "14", ":", "16", "]", "# Attempts to add the correct dictionary of special words", "try", ":", "specialwords_dict", "=", "specialwords_dict_full", "[", "src_lang", "+", "'_'", "+", "dest_lang", "]", "except", "KeyError", ":", "print", "(", "'Special words file doesn\\'t contain required language translation!'", ")", "# Parses each line for special cases and ignores them when translating", "for", "line", "in", "lines", ":", "line", "=", "line", ".", "strip", "(", ")", "# Parses for code blocks and ignores them entirely", "if", "line", ".", "startswith", "(", "\"```\"", ")", ":", "line", "=", "line", "else", ":", "# Parses for URL's and file links and ignores them", "if", "line", ".", "find", "(", "\"[\"", ")", "!=", "-", "1", "and", "line", ".", "find", "(", "\"]\"", ")", "!=", "-", "1", "and", "line", ".", "find", "(", "\"(\"", ")", "!=", "-", "1", "and", "line", ".", "find", "(", "\")\"", ")", "!=", "-", "1", ":", "ignore_start", "=", "line", ".", "find", "(", "\"(\"", ")", "ignore_end", "=", "line", ".", "find", "(", "\")\"", ")", "head", "=", "replace", "(", "specialwords_dict", ",", "line", "[", "0", ":", "ignore_start", "]", ")", "tail", "=", "replace", "(", "specialwords_dict", ",", "line", "[", "ignore_end", "+", "1", ":", "]", ")", "head", "=", "translator", ".", "translate", "(", "head", ",", "dest_lang", ",", "src_lang", ")", ".", "text", "tail", "=", "translator", ".", "translate", "(", "tail", ",", "dest_lang", ",", "src_lang", ")", ".", "text", "line", "=", "head", "+", "line", "[", "ignore_start", ":", "ignore_end", "+", "1", "]", "+", "tail", "# Translates normally if there are no special cases", "else", ":", "line", "=", "translator", ".", "translate", "(", "line", ",", "dest_lang", ",", "src_lang", ")", ".", "text", "# Write to destination file", "destfile", ".", "write", "(", "line", "+", "'\\n'", ")" ]

[ "Converts", "a", "source", "file", "to", "a", "destination", "file", "in", "the", "selected", "language", "." ]

[ "def", "deprecated", "(", "f", ")", ":", "def", "inner_func", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "print", "(", "textwrap", ".", "dedent", "(", "\"\"\"\\\n This command is deprecated and is subject to complete\n removal at any later version without notice.\n \"\"\"", ")", ")", "f", "(", "*", "args", ",", "*", "*", "kwargs", ")", "inner_func", ".", "__deprecated__", "=", "True", "inner_func", ".", "__doc__", "=", "f", ".", "__doc__", "inner_func", ".", "__name__", "=", "f", ".", "__name__", "if", "iscommand", "(", "f", ")", ":", "inner_func", ".", "__command__", "=", "f", ".", "__command__", "return", "inner_func" ]

[ "Decorate", "a", "function", "object", "as", "deprecated", "." ]

[ "def", "helper", "(", "*", "commands", ")", ":", "def", "decorated_func", "(", "f", ")", ":", "f", ".", "__help_targets__", "=", "list", "(", "commands", ")", "return", "f", "return", "decorated_func" ]

[ "Decorate", "a", "function", "to", "be", "the", "helper", "function", "of", "commands", "." ]

[ "def", "completer", "(", "*", "commands", ")", ":", "def", "decorated_func", "(", "f", ")", ":", "f", ".", "__complete_targets__", "=", "list", "(", "commands", ")", "return", "f", "return", "decorated_func" ]

[ "Decorate", "a", "function", "to", "be", "the", "completer", "function", "of", "commands", "." ]

[ "def", "subshell", "(", "shell_cls", ",", "*", "commands", ",", "*", "*", "kwargs", ")", ":", "def", "decorated_func", "(", "f", ")", ":", "def", "inner_func", "(", "self", ",", "cmd", ",", "args", ")", ":", "retval", "=", "f", "(", "self", ",", "cmd", ",", "args", ")", "# Do not launch the subshell if the return value is None.", "if", "not", "retval", ":", "return", "# Pass the context (see the doc string) to the subshell if the", "# return value is a 2-tuple. Otherwise, the context is just an empty", "# dictionary.", "if", "isinstance", "(", "retval", ",", "tuple", ")", ":", "prompt", ",", "context", "=", "retval", "else", ":", "prompt", "=", "retval", "context", "=", "{", "}", "return", "self", ".", "launch_subshell", "(", "shell_cls", ",", "cmd", ",", "args", ",", "prompt", "=", "prompt", ",", "context", "=", "context", ")", "inner_func", ".", "__name__", "=", "f", ".", "__name__", "inner_func", ".", "__doc__", "=", "f", ".", "__doc__", "obj", "=", "command", "(", "*", "commands", ",", "*", "*", "kwargs", ")", "(", "inner_func", ")", "if", "commands", "else", "inner_func", "obj", ".", "__launch_subshell__", "=", "shell_cls", "return", "obj", "return", "decorated_func" ]

[ "Decorate", "a", "function", "to", "conditionally", "launch", "a", "_ShellBase", "subshell", "." ]

[ "def", "doc_string", "(", "cls", ")", ":", "clz", "=", "cls", "while", "not", "clz", ".", "__doc__", ":", "clz", "=", "clz", ".", "__bases__", "[", "0", "]", "return", "clz", ".", "__doc__" ]

[ "Get", "the", "doc", "string", "of", "this", "class", "." ]

[ "def", "launch_subshell", "(", "self", ",", "shell_cls", ",", "cmd", ",", "args", ",", "*", ",", "prompt", "=", "None", ",", "context", "=", "{", "}", ")", ":", "# Save history of the current shell.", "readline", ".", "write_history_file", "(", "self", ".", "history_fname", ")", "prompt", "=", "prompt", "if", "prompt", "else", "shell_cls", ".", "__name__", "mode", "=", "_ShellBase", ".", "_Mode", "(", "shell", "=", "self", ",", "cmd", "=", "cmd", ",", "args", "=", "args", ",", "prompt", "=", "prompt", ",", "context", "=", "context", ",", ")", "shell", "=", "shell_cls", "(", "batch_mode", "=", "self", ".", "batch_mode", ",", "debug", "=", "self", ".", "debug", ",", "mode_stack", "=", "self", ".", "_mode_stack", "+", "[", "mode", "]", ",", "pipe_end", "=", "self", ".", "_pipe_end", ",", "root_prompt", "=", "self", ".", "root_prompt", ",", "stdout", "=", "self", ".", "stdout", ",", "stderr", "=", "self", ".", "stderr", ",", "temp_dir", "=", "self", ".", "_temp_dir", ",", ")", "# The subshell creates its own history context.", "self", ".", "print_debug", "(", "\"Leave parent shell '{}'\"", ".", "format", "(", "self", ".", "prompt", ")", ")", "exit_directive", "=", "shell", ".", "cmdloop", "(", ")", "self", ".", "print_debug", "(", "\"Enter parent shell '{}': {}\"", ".", "format", "(", "self", ".", "prompt", ",", "exit_directive", ")", ")", "# Restore history. The subshell could have deleted the history file of", "# this shell via 'history clearall'.", "readline", ".", "clear_history", "(", ")", "if", "os", ".", "path", ".", "isfile", "(", "self", ".", "history_fname", ")", ":", "readline", ".", "read_history_file", "(", "self", ".", "history_fname", ")", "if", "not", "exit_directive", "is", "True", ":", "return", "exit_directive" ]

[ "Launch", "a", "subshell", "." ]

[ "def", "batch_string", "(", "self", ",", "content", ")", ":", "pipe_send", ",", "pipe_recv", "=", "multiprocessing", ".", "Pipe", "(", ")", "self", ".", "_pipe_end", "=", "pipe_recv", "proc", "=", "multiprocessing", ".", "Process", "(", "target", "=", "self", ".", "cmdloop", ")", "for", "line", "in", "content", ".", "split", "(", "'\\n'", ")", ":", "pipe_send", ".", "send", "(", "line", ")", "pipe_send", ".", "close", "(", ")", "proc", ".", "start", "(", ")", "proc", ".", "join", "(", ")" ]

[ "Process", "a", "string", "in", "batch", "mode", "." ]

[ "def", "cmdloop", "(", "self", ")", ":", "self", ".", "print_debug", "(", "\"Enter subshell '{}'\"", ".", "format", "(", "self", ".", "prompt", ")", ")", "# Save the completer function, the history buffer, and the", "# completer_delims.", "old_completer", "=", "readline", ".", "get_completer", "(", ")", "old_delims", "=", "readline", ".", "get_completer_delims", "(", ")", "new_delims", "=", "''", ".", "join", "(", "list", "(", "set", "(", "old_delims", ")", "-", "set", "(", "_ShellBase", ".", "_non_delims", ")", ")", ")", "readline", ".", "set_completer_delims", "(", "new_delims", ")", "# Load the new completer function and start a new history buffer.", "readline", ".", "set_completer", "(", "self", ".", "__driver_stub", ")", "readline", ".", "clear_history", "(", ")", "if", "os", ".", "path", ".", "isfile", "(", "self", ".", "history_fname", ")", ":", "readline", ".", "read_history_file", "(", "self", ".", "history_fname", ")", "# main loop", "try", ":", "# The exit_directive:", "# True Leave this shell, enter the parent shell.", "# False Continue with the loop.", "# 'root' Exit to the root shell.", "# 'all' Exit to the command line.", "# an integer The depth of the shell to exit to. 0 = root", "# shell. Negative number is taken as error.", "self", ".", "preloop", "(", ")", "while", "True", ":", "exit_directive", "=", "False", "try", ":", "if", "self", ".", "batch_mode", ":", "line", "=", "self", ".", "_pipe_end", ".", "recv", "(", ")", "else", ":", "line", "=", "input", "(", "self", ".", "prompt", ")", ".", "strip", "(", ")", "except", "EOFError", ":", "line", "=", "_ShellBase", ".", "EOF", "try", ":", "exit_directive", "=", "self", ".", "__exec_line__", "(", "line", ")", "except", ":", "self", ".", "stderr", ".", "write", "(", "traceback", ".", "format_exc", "(", ")", ")", "if", "type", "(", "exit_directive", ")", "is", "int", ":", "if", "len", "(", "self", ".", "_mode_stack", ")", ">", "exit_directive", ":", "break", "if", "len", "(", "self", ".", "_mode_stack", ")", "==", "exit_directive", ":", "continue", "if", "self", ".", "_mode_stack", "and", "exit_directive", "==", "'root'", ":", "break", "if", "exit_directive", "in", "{", "'all'", ",", "True", ",", "}", ":", "break", "finally", ":", "self", ".", "postloop", "(", ")", "# Restore the completer function, save the history, and restore old", "# delims.", "readline", ".", "set_completer", "(", "old_completer", ")", "readline", ".", "write_history_file", "(", "self", ".", "history_fname", ")", "readline", ".", "set_completer_delims", "(", "old_delims", ")", "self", ".", "print_debug", "(", "\"Leave subshell '{}': {}\"", ".", "format", "(", "self", ".", "prompt", ",", "exit_directive", ")", ")", "return", "exit_directive" ]

[ "Start", "the", "main", "loop", "of", "the", "interactive", "shell", "." ]

[ "def", "parse_line", "(", "self", ",", "line", ")", ":", "toks", "=", "shlex", ".", "split", "(", "line", ")", "# Safe to index the 0-th element because this line would have been", "# parsed by __exec_line__ if toks is an empty list.", "return", "(", "toks", "[", "0", "]", ",", "[", "]", "if", "len", "(", "toks", ")", "==", "1", "else", "toks", "[", "1", ":", "]", ")" ]

[ "Parse", "a", "line", "of", "input", "." ]

[ "def", "__driver_stub", "(", "self", ",", "text", ",", "state", ")", ":", "origline", "=", "readline", ".", "get_line_buffer", "(", ")", "line", "=", "origline", ".", "lstrip", "(", ")", "if", "line", "and", "line", "[", "-", "1", "]", "==", "'?'", ":", "self", ".", "__driver_helper", "(", "line", ")", "else", ":", "toks", "=", "shlex", ".", "split", "(", "line", ")", "return", "self", ".", "__driver_completer", "(", "toks", ",", "text", ",", "state", ")" ]

[ "Display", "help", "messages", "or", "invoke", "the", "proper", "completer", "." ]

[ "def", "__driver_completer", "(", "self", ",", "toks", ",", "text", ",", "state", ")", ":", "if", "state", "!=", "0", ":", "return", "self", ".", "__completion_candidates", "[", "state", "]", "# Update the cache when this method is first called, i.e., state == 0.", "# If the line is empty or the user is still inputing the first token,", "# complete with available commands.", "if", "not", "toks", "or", "(", "len", "(", "toks", ")", "==", "1", "and", "text", "==", "toks", "[", "0", "]", ")", ":", "try", ":", "self", ".", "__completion_candidates", "=", "self", ".", "__complete_cmds", "(", "text", ")", "except", ":", "self", ".", "stderr", ".", "write", "(", "'\\n'", ")", "self", ".", "stderr", ".", "write", "(", "traceback", ".", "format_exc", "(", ")", ")", "self", ".", "__completion_candidates", "=", "[", "]", "return", "self", ".", "__completion_candidates", "[", "state", "]", "# Otherwise, try to complete with the registered completer method.", "cmd", "=", "toks", "[", "0", "]", "args", "=", "toks", "[", "1", ":", "]", "if", "len", "(", "toks", ")", ">", "1", "else", "None", "if", "text", "and", "args", ":", "del", "args", "[", "-", "1", "]", "if", "cmd", "in", "self", ".", "_completer_map", ".", "keys", "(", ")", ":", "completer_name", "=", "self", ".", "_completer_map", "[", "cmd", "]", "completer_method", "=", "getattr", "(", "self", ",", "completer_name", ")", "try", ":", "self", ".", "__completion_candidates", "=", "completer_method", "(", "cmd", ",", "args", ",", "text", ")", "except", ":", "self", ".", "stderr", ".", "write", "(", "'\\n'", ")", "self", ".", "stderr", ".", "write", "(", "traceback", ".", "format_exc", "(", ")", ")", "self", ".", "__completion_candidates", "=", "[", "]", "else", ":", "self", ".", "__completion_candidates", "=", "[", "]", "return", "self", ".", "__completion_candidates", "[", "state", "]" ]

[ "Driver", "level", "completer", "." ]

[ "def", "__complete_cmds", "(", "self", ",", "text", ")", ":", "return", "[", "name", "for", "name", "in", "self", ".", "_cmd_map_visible", ".", "keys", "(", ")", "if", "name", ".", "startswith", "(", "text", ")", "]" ]

[ "Get", "the", "list", "of", "commands", "whose", "names", "start", "with", "a", "given", "text", "." ]

[ "def", "__driver_helper", "(", "self", ",", "line", ")", ":", "if", "line", ".", "strip", "(", ")", "==", "'?'", ":", "self", ".", "stdout", ".", "write", "(", "'\\n'", ")", "self", ".", "stdout", ".", "write", "(", "self", ".", "doc_string", "(", ")", ")", "else", ":", "toks", "=", "shlex", ".", "split", "(", "line", "[", ":", "-", "1", "]", ")", "try", ":", "msg", "=", "self", ".", "__get_help_message", "(", "toks", ")", "except", "Exception", "as", "e", ":", "self", ".", "stderr", ".", "write", "(", "'\\n'", ")", "self", ".", "stderr", ".", "write", "(", "traceback", ".", "format_exc", "(", ")", ")", "self", ".", "stderr", ".", "flush", "(", ")", "self", ".", "stdout", ".", "write", "(", "'\\n'", ")", "self", ".", "stdout", ".", "write", "(", "msg", ")", "# Restore the prompt and the original input.", "self", ".", "stdout", ".", "write", "(", "'\\n'", ")", "self", ".", "stdout", ".", "write", "(", "self", ".", "prompt", ")", "self", ".", "stdout", ".", "write", "(", "line", ")", "self", ".", "stdout", ".", "flush", "(", ")" ]

[ "Driver", "level", "helper", "method", "." ]

[ "def", "__build_cmd_maps", "(", "cls", ")", ":", "cmd_map_all", "=", "{", "}", "cmd_map_visible", "=", "{", "}", "cmd_map_internal", "=", "{", "}", "for", "name", "in", "dir", "(", "cls", ")", ":", "obj", "=", "getattr", "(", "cls", ",", "name", ")", "if", "iscommand", "(", "obj", ")", ":", "for", "cmd", "in", "getcommands", "(", "obj", ")", ":", "if", "cmd", "in", "cmd_map_all", ".", "keys", "(", ")", ":", "raise", "PyShellError", "(", "\"The command '{}' already has cmd\"", "\" method '{}', cannot register a\"", "\" second method '{}'.\"", ".", "format", "(", "cmd", ",", "cmd_map_all", "[", "cmd", "]", ",", "obj", ".", "__name__", ")", ")", "cmd_map_all", "[", "cmd", "]", "=", "obj", ".", "__name__", "if", "isvisiblecommand", "(", "obj", ")", ":", "cmd_map_visible", "[", "cmd", "]", "=", "obj", ".", "__name__", "if", "isinternalcommand", "(", "obj", ")", ":", "cmd_map_internal", "[", "cmd", "]", "=", "obj", ".", "__name__", "return", "cmd_map_all", ",", "cmd_map_visible", ",", "cmd_map_internal" ]

[ "Build", "the", "mapping", "from", "command", "names", "to", "method", "names", "." ]

[ "def", "__build_helper_map", "(", "cls", ")", ":", "ret", "=", "{", "}", "for", "name", "in", "dir", "(", "cls", ")", ":", "obj", "=", "getattr", "(", "cls", ",", "name", ")", "if", "ishelper", "(", "obj", ")", ":", "for", "cmd", "in", "obj", ".", "__help_targets__", ":", "if", "cmd", "in", "ret", ".", "keys", "(", ")", ":", "raise", "PyShellError", "(", "\"The command '{}' already has helper\"", "\" method '{}', cannot register a\"", "\" second method '{}'.\"", ".", "format", "(", "cmd", ",", "ret", "[", "cmd", "]", ",", "obj", ".", "__name__", ")", ")", "ret", "[", "cmd", "]", "=", "obj", ".", "__name__", "return", "ret" ]

[ "Build", "a", "mapping", "from", "command", "names", "to", "helper", "names", "." ]

[ "def", "__build_completer_map", "(", "cls", ")", ":", "ret", "=", "{", "}", "for", "name", "in", "dir", "(", "cls", ")", ":", "obj", "=", "getattr", "(", "cls", ",", "name", ")", "if", "iscompleter", "(", "obj", ")", ":", "for", "cmd", "in", "obj", ".", "__complete_targets__", ":", "if", "cmd", "in", "ret", ".", "keys", "(", ")", ":", "raise", "PyShellError", "(", "\"The command '{}' already has\"", "\" complter\"", "\" method '{}', cannot register a\"", "\" second method '{}'.\"", ".", "format", "(", "cmd", ",", "ret", "[", "cmd", "]", ",", "obj", ".", "__name__", ")", ")", "ret", "[", "cmd", "]", "=", "obj", ".", "__name__", "return", "ret" ]

[ "Build", "a", "mapping", "from", "command", "names", "to", "completer", "names", "." ]

[ "def", "review_score", "(", "self", ",", "reviewer", ",", "product", ")", ":", "return", "self", ".", "_g", ".", "retrieve_review", "(", "reviewer", ",", "product", ")", ".", "score" ]

[ "Find", "a", "review", "score", "from", "a", "given", "reviewer", "to", "a", "product", "." ]

[ "def", "from_dict", "(", "cls", ":", "typing", ".", "Type", "[", "T", "]", ",", "dikt", ")", "->", "T", ":", "return", "util", ".", "deserialize_model", "(", "dikt", ",", "cls", ")" ]

[ "Returns", "the", "dict", "as", "a", "model" ]

[ "def", "get_defs", "(", "self", ",", "cache", "=", "True", ")", ":", "log", ".", "debug", "(", "\" *** Started\"", ")", "cache", "=", "self", ".", "__use_cache__", "(", "cache", ")", "if", "cache", ":", "log", ".", "info", "(", "\" loading json cache\"", ")", "try", ":", "with", "open", "(", "self", ".", "cache_filepath", ")", "as", "file_obj", ":", "self", ".", "results", "=", "json", ".", "loads", "(", "file_obj", ".", "read", "(", ")", ")", "except", "FileNotFoundError", ":", "self", ".", "results", "=", "[", "]", "if", "not", "cache", "or", "len", "(", "self", ".", "results", ")", "==", "0", ":", "log", ".", "info", "(", "\" NO CACHE, querying the triplestore\"", ")", "sparql", "=", "render_without_request", "(", "self", ".", "def_sparql", ",", "graph", "=", "self", ".", "conn", ".", "graph", ",", "prefix", "=", "self", ".", "nsm", ".", "prefix", "(", ")", ")", "start", "=", "datetime", ".", "datetime", ".", "now", "(", ")", "log", ".", "info", "(", "\" Starting query\"", ")", "self", ".", "results", "=", "self", ".", "conn", ".", "query", "(", "sparql", ")", "log", ".", "info", "(", "\"query complete in: %s | %s triples retrieved.\"", ",", "(", "datetime", ".", "datetime", ".", "now", "(", ")", "-", "start", ")", ",", "len", "(", "self", ".", "results", ")", ")", "with", "open", "(", "self", ".", "cache_filepath", ",", "\"w\"", ")", "as", "file_obj", ":", "file_obj", ".", "write", "(", "json", ".", "dumps", "(", "self", ".", "results", ",", "indent", "=", "4", ")", ")", "with", "open", "(", "self", ".", "loaded_filepath", ",", "\"w\"", ")", "as", "file_obj", ":", "file_obj", ".", "write", "(", "(", "json", ".", "dumps", "(", "self", ".", "conn", ".", "mgr", ".", "loaded", ")", ")", ")" ]

[ "Gets", "the", "defitions" ]

[ "def", "conv_defs", "(", "self", ")", ":", "log", ".", "setLevel", "(", "self", ".", "log_level", ")", "start", "=", "datetime", ".", "datetime", ".", "now", "(", ")", "log", ".", "debug", "(", "\" Converting to a Dataset: %s Triples\"", ",", "len", "(", "self", ".", "results", ")", ")", "self", ".", "defs", "=", "RdfDataset", "(", "self", ".", "results", ",", "def_load", "=", "True", ",", "bnode_only", "=", "True", ")", "# self.cfg.__setattr__('rdf_prop_defs', self.defs, True)", "log", ".", "debug", "(", "\" conv complete in: %s\"", "%", "(", "datetime", ".", "datetime", ".", "now", "(", ")", "-", "start", ")", ")" ]

[ "Reads", "through", "the", "JSON", "object", "and", "converts", "them", "to", "Dataset" ]

[ "def", "set_class_dict", "(", "self", ")", ":", "self", ".", "class_dict", "=", "{", "}", "for", "name", ",", "cls_defs", "in", "self", ".", "defs", ".", "items", "(", ")", ":", "def_type", "=", "set", "(", "cls_defs", ".", "get", "(", "self", ".", "rdf_type", ",", "[", "]", ")", ")", "if", "name", ".", "type", "==", "'bnode'", ":", "continue", "# a class can be determined by checking to see if it is of an", "# rdf_type listed in the classes_key or has a property that is", "# listed in the inferred_key", "if", "def_type", ".", "intersection", "(", "self", ".", "classes_key", ")", "or", "list", "(", "[", "cls_defs", ".", "get", "(", "item", ")", "for", "item", "in", "self", ".", "inferred_key", "]", ")", ":", "self", ".", "class_dict", "[", "name", "]", "=", "cls_defs" ]

[ "Reads", "through", "the", "dataset", "and", "assigns", "self", ".", "class_dict", "the", "key", "value", "pairs", "for", "the", "classes", "in", "the", "dataset" ]

[ "def", "tie_properties", "(", "self", ",", "class_list", ")", ":", "log", ".", "setLevel", "(", "self", ".", "log_level", ")", "start", "=", "datetime", ".", "datetime", ".", "now", "(", ")", "log", ".", "info", "(", "\" Tieing properties to the class\"", ")", "for", "cls_name", "in", "class_list", ":", "cls_obj", "=", "getattr", "(", "MODULE", ".", "rdfclass", ",", "cls_name", ")", "prop_dict", "=", "dict", "(", "cls_obj", ".", "properties", ")", "for", "prop_name", ",", "prop_obj", "in", "cls_obj", ".", "properties", ".", "items", "(", ")", ":", "setattr", "(", "cls_obj", ",", "prop_name", ",", "link_property", "(", "prop_obj", ",", "cls_obj", ")", ")", "log", ".", "info", "(", "\" Finished tieing properties in: %s\"", ",", "(", "datetime", ".", "datetime", ".", "now", "(", ")", "-", "start", ")", ")" ]

[ "Runs", "through", "the", "classess", "and", "ties", "the", "properties", "to", "the", "class" ]

[ "def", "elemgetter", "(", "path", ":", "str", ")", "->", "t", ".", "Callable", "[", "[", "Element", "]", ",", "Element", "]", ":", "return", "compose", "(", "partial", "(", "_raise_if_none", ",", "exc", "=", "LookupError", "(", "path", ")", ")", ",", "methodcaller", "(", "'find'", ",", "path", ")", ")" ]

[ "shortcut", "making", "an", "XML", "element", "getter" ]

[ "def", "textgetter", "(", "path", ":", "str", ",", "*", ",", "default", ":", "T", "=", "NO_DEFAULT", ",", "strip", ":", "bool", "=", "False", ")", "->", "t", ".", "Callable", "[", "[", "Element", "]", ",", "t", ".", "Union", "[", "str", ",", "T", "]", "]", ":", "find", "=", "compose", "(", "str", ".", "strip", "if", "strip", "else", "identity", ",", "partial", "(", "_raise_if_none", ",", "exc", "=", "LookupError", "(", "path", ")", ")", ",", "methodcaller", "(", "'findtext'", ",", "path", ")", ")", "return", "(", "find", "if", "default", "is", "NO_DEFAULT", "else", "lookup_defaults", "(", "find", ",", "default", ")", ")" ]

[ "shortcut", "for", "making", "an", "XML", "element", "text", "getter" ]

[ "def", "_parse_alt_url", "(", "html_chunk", ")", ":", "url_list", "=", "html_chunk", ".", "find", "(", "\"a\"", ",", "fn", "=", "has_param", "(", "\"href\"", ")", ")", "url_list", "=", "map", "(", "lambda", "x", ":", "x", ".", "params", "[", "\"href\"", "]", ",", "url_list", ")", "url_list", "=", "filter", "(", "lambda", "x", ":", "not", "x", ".", "startswith", "(", "\"autori/\"", ")", ",", "url_list", ")", "if", "not", "url_list", ":", "return", "None", "return", "normalize_url", "(", "BASE_URL", ",", "url_list", "[", "0", "]", ")" ]

[ "Parse", "URL", "from", "alternative", "location", "if", "not", "found", "where", "it", "should", "be", "." ]