Datasets:

---

AISE-TUDelft

/

ML4SE23_G8_CodeSearchNet-Python

like 0

Follow

AISE research lab at TU Delft 55

[ "def", "shutdown", "(", "cls", ")", ":", "for", "pid", "in", "list", "(", "cls", ".", "_pools", ".", "keys", "(", ")", ")", ":", "cls", ".", "_pools", "[", "pid", "]", ".", "shutdown", "(", ")", "LOGGER", ".", "info", "(", "'Shutdown complete, all pooled connections closed'", ")" ]

[ "Close", "all", "connections", "on", "in", "all", "pools" ]

[ "def", "size", "(", "cls", ",", "pid", ")", ":", "with", "cls", ".", "_lock", ":", "cls", ".", "_ensure_pool_exists", "(", "pid", ")", "return", "len", "(", "cls", ".", "_pools", "[", "pid", "]", ")" ]

[ "Return", "the", "number", "of", "connections", "in", "the", "pool" ]

[ "def", "report", "(", "cls", ")", ":", "return", "{", "'timestamp'", ":", "datetime", ".", "datetime", ".", "utcnow", "(", ")", ".", "isoformat", "(", ")", ",", "'process'", ":", "os", ".", "getpid", "(", ")", ",", "'pools'", ":", "dict", "(", "[", "(", "i", ",", "p", ".", "report", "(", ")", ")", "for", "i", ",", "p", "in", "cls", ".", "_pools", ".", "items", "(", ")", "]", ")", "}" ]

[ "Return", "the", "state", "of", "the", "all", "of", "the", "registered", "pools", "." ]

[ "def", "_maybe_remove_pool", "(", "cls", ",", "pid", ")", ":", "if", "not", "len", "(", "cls", ".", "_pools", "[", "pid", "]", ")", ":", "del", "cls", ".", "_pools", "[", "pid", "]" ]

[ "If", "the", "pool", "has", "no", "open", "connections", "remove", "it" ]

[ "def", "close", "(", "self", ")", ":", "if", "not", "self", ".", "_conn", ":", "raise", "psycopg2", ".", "InterfaceError", "(", "'Connection not open'", ")", "LOGGER", ".", "info", "(", "'Closing connection %r in %s'", ",", "self", ".", "_conn", ",", "self", ".", "pid", ")", "self", ".", "_pool_manager", ".", "free", "(", "self", ".", "pid", ",", "self", ".", "_conn", ")", "self", ".", "_pool_manager", ".", "remove_connection", "(", "self", ".", "pid", ",", "self", ".", "_conn", ")", "# Un-assign the connection and cursor", "self", ".", "_conn", ",", "self", ".", "_cursor", "=", "None", ",", "None" ]

[ "Explicitly", "close", "the", "connection", "and", "remove", "it", "from", "the", "connection", "pool", "if", "pooling", "is", "enabled", ".", "If", "the", "connection", "is", "already", "closed" ]

[ "def", "pid", "(", "self", ")", ":", "return", "hashlib", ".", "md5", "(", "':'", ".", "join", "(", "[", "self", ".", "__class__", ".", "__name__", ",", "self", ".", "_uri", "]", ")", ".", "encode", "(", "'utf-8'", ")", ")", ".", "hexdigest", "(", ")" ]

[ "Return", "the", "pool", "ID", "used", "for", "connection", "pooling", "." ]

[ "def", "set_encoding", "(", "self", ",", "value", "=", "DEFAULT_ENCODING", ")", ":", "if", "self", ".", "_conn", ".", "encoding", "!=", "value", ":", "self", ".", "_conn", ".", "set_client_encoding", "(", "value", ")" ]

[ "Set", "the", "client", "encoding", "for", "the", "session", "if", "the", "value", "specified", "is", "different", "than", "the", "current", "client", "encoding", "." ]

[ "def", "_cleanup", "(", "self", ")", ":", "if", "self", ".", "_cursor", ":", "LOGGER", ".", "debug", "(", "'Closing the cursor on %s'", ",", "self", ".", "pid", ")", "self", ".", "_cursor", ".", "close", "(", ")", "self", ".", "_cursor", "=", "None", "if", "self", ".", "_conn", ":", "LOGGER", ".", "debug", "(", "'Freeing %s in the pool'", ",", "self", ".", "pid", ")", "try", ":", "pool", ".", "PoolManager", ".", "instance", "(", ")", ".", "free", "(", "self", ".", "pid", ",", "self", ".", "_conn", ")", "except", "pool", ".", "ConnectionNotFoundError", ":", "pass", "self", ".", "_conn", "=", "None" ]

[ "Remove", "the", "connection", "from", "the", "stack", "closing", "out", "the", "cursor" ]

[ "def", "_get_cursor", "(", "self", ",", "connection", ",", "name", "=", "None", ")", ":", "cursor", "=", "connection", ".", "cursor", "(", "name", "=", "name", ",", "cursor_factory", "=", "self", ".", "_cursor_factory", ")", "if", "name", "is", "not", "None", ":", "cursor", ".", "scrollable", "=", "True", "cursor", ".", "withhold", "=", "True", "return", "cursor" ]

[ "Return", "a", "cursor", "for", "the", "given", "cursor_factory", ".", "Specify", "a", "name", "to", "use", "server", "-", "side", "cursors", "." ]

[ "def", "_register_unicode", "(", "connection", ")", ":", "psycopg2", ".", "extensions", ".", "register_type", "(", "psycopg2", ".", "extensions", ".", "UNICODE", ",", "connection", ")", "psycopg2", ".", "extensions", ".", "register_type", "(", "psycopg2", ".", "extensions", ".", "UNICODEARRAY", ",", "connection", ")" ]

[ "Register", "the", "cursor", "to", "be", "able", "to", "receive", "Unicode", "string", "." ]

[ "def", "_status", "(", "self", ")", ":", "if", "self", ".", "_conn", ".", "status", "==", "psycopg2", ".", "extensions", ".", "STATUS_BEGIN", ":", "return", "self", ".", "READY", "return", "self", ".", "_conn", ".", "status" ]

[ "Return", "the", "current", "connection", "status", "as", "an", "integer", "value", "." ]

[ "def", "items", "(", "self", ")", ":", "if", "not", "self", ".", "cursor", ".", "rowcount", ":", "return", "[", "]", "self", ".", "cursor", ".", "scroll", "(", "0", ",", "'absolute'", ")", "return", "self", ".", "cursor", ".", "fetchall", "(", ")" ]

[ "Return", "all", "of", "the", "rows", "that", "are", "in", "the", "result", "set", "." ]

[ "def", "get_current_user", "(", ")", ":", "if", "pwd", "is", "None", ":", "return", "getpass", ".", "getuser", "(", ")", "else", ":", "try", ":", "return", "pwd", ".", "getpwuid", "(", "os", ".", "getuid", "(", ")", ")", "[", "0", "]", "except", "KeyError", "as", "error", ":", "LOGGER", ".", "error", "(", "'Could not get logged-in user: %s'", ",", "error", ")" ]

[ "Return", "the", "current", "username", "for", "the", "logged", "in", "user" ]

[ "def", "uri", "(", "host", "=", "'localhost'", ",", "port", "=", "5432", ",", "dbname", "=", "'postgres'", ",", "user", "=", "'postgres'", ",", "password", "=", "None", ")", ":", "if", "port", ":", "host", "=", "'%s:%s'", "%", "(", "host", ",", "port", ")", "if", "password", ":", "return", "'postgresql://%s:%s@%s/%s'", "%", "(", "user", ",", "password", ",", "host", ",", "dbname", ")", "return", "'postgresql://%s@%s/%s'", "%", "(", "user", ",", "host", ",", "dbname", ")" ]

[ "Return", "a", "PostgreSQL", "connection", "URI", "for", "the", "specified", "values", "." ]

[ "def", "uri_to_kwargs", "(", "uri", ")", ":", "parsed", "=", "urlparse", "(", "uri", ")", "default_user", "=", "get_current_user", "(", ")", "password", "=", "unquote", "(", "parsed", ".", "password", ")", "if", "parsed", ".", "password", "else", "None", "kwargs", "=", "{", "'host'", ":", "parsed", ".", "hostname", ",", "'port'", ":", "parsed", ".", "port", ",", "'dbname'", ":", "parsed", ".", "path", "[", "1", ":", "]", "or", "default_user", ",", "'user'", ":", "parsed", ".", "username", "or", "default_user", ",", "'password'", ":", "password", "}", "values", "=", "parse_qs", "(", "parsed", ".", "query", ")", "if", "'host'", "in", "values", ":", "kwargs", "[", "'host'", "]", "=", "values", "[", "'host'", "]", "[", "0", "]", "for", "k", "in", "[", "k", "for", "k", "in", "values", "if", "k", "in", "KEYWORDS", "]", ":", "kwargs", "[", "k", "]", "=", "values", "[", "k", "]", "[", "0", "]", "if", "len", "(", "values", "[", "k", "]", ")", "==", "1", "else", "values", "[", "k", "]", "try", ":", "if", "kwargs", "[", "k", "]", ".", "isdigit", "(", ")", ":", "kwargs", "[", "k", "]", "=", "int", "(", "kwargs", "[", "k", "]", ")", "except", "AttributeError", ":", "pass", "return", "kwargs" ]

[ "Return", "a", "URI", "as", "kwargs", "for", "connecting", "to", "PostgreSQL", "with", "psycopg2", "applying", "default", "values", "for", "non", "-", "specified", "areas", "of", "the", "URI", "." ]

[ "def", "_ensure_pool_exists", "(", "self", ")", ":", "if", "self", ".", "pid", "not", "in", "self", ".", "_pool_manager", ":", "self", ".", "_pool_manager", ".", "create", "(", "self", ".", "pid", ",", "self", ".", "_pool_idle_ttl", ",", "self", ".", "_pool_max_size", ",", "self", ".", "_ioloop", ".", "time", ")" ]

[ "Create", "the", "pool", "in", "the", "pool", "manager", "if", "it", "does", "not", "exist", "." ]

[ "def", "_create_connection", "(", "self", ",", "future", ")", ":", "LOGGER", ".", "debug", "(", "'Creating a new connection for %s'", ",", "self", ".", "pid", ")", "# Create a new PostgreSQL connection", "kwargs", "=", "utils", ".", "uri_to_kwargs", "(", "self", ".", "_uri", ")", "try", ":", "connection", "=", "self", ".", "_psycopg2_connect", "(", "kwargs", ")", "except", "(", "psycopg2", ".", "Error", ",", "OSError", ",", "socket", ".", "error", ")", "as", "error", ":", "future", ".", "set_exception", "(", "error", ")", "return", "# Add the connection for use in _poll_connection", "fd", "=", "connection", ".", "fileno", "(", ")", "self", ".", "_connections", "[", "fd", "]", "=", "connection", "def", "on_connected", "(", "cf", ")", ":", "\"\"\"Invoked by the IOLoop when the future is complete for the\n connection\n\n :param Future cf: The future for the initial connection\n\n \"\"\"", "if", "cf", ".", "exception", "(", ")", ":", "self", ".", "_cleanup_fd", "(", "fd", ",", "True", ")", "future", ".", "set_exception", "(", "cf", ".", "exception", "(", ")", ")", "else", ":", "try", ":", "# Add the connection to the pool", "LOGGER", ".", "debug", "(", "'Connection established for %s'", ",", "self", ".", "pid", ")", "self", ".", "_pool_manager", ".", "add", "(", "self", ".", "pid", ",", "connection", ")", "except", "(", "ValueError", ",", "pool", ".", "PoolException", ")", "as", "err", ":", "LOGGER", ".", "exception", "(", "'Failed to add %r to the pool'", ",", "self", ".", "pid", ")", "self", ".", "_cleanup_fd", "(", "fd", ")", "future", ".", "set_exception", "(", "err", ")", "return", "self", ".", "_pool_manager", ".", "lock", "(", "self", ".", "pid", ",", "connection", ",", "self", ")", "# Added in because psycopg2cffi connects and leaves the", "# connection in a weird state: consts.STATUS_DATESTYLE,", "# returning from Connection._setup without setting the state", "# as const.STATUS_OK", "if", "utils", ".", "PYPY", ":", "connection", ".", "status", "=", "extensions", ".", "STATUS_READY", "# Register the custom data types", "self", ".", "_register_unicode", "(", "connection", ")", "self", ".", "_register_uuid", "(", "connection", ")", "# Set the future result", "future", ".", "set_result", "(", "connection", ")", "# Add a future that fires once connected", "self", ".", "_futures", "[", "fd", "]", "=", "concurrent", ".", "Future", "(", ")", "self", ".", "_ioloop", ".", "add_future", "(", "self", ".", "_futures", "[", "fd", "]", ",", "on_connected", ")", "# Add the connection to the IOLoop", "self", ".", "_ioloop", ".", "add_handler", "(", "connection", ".", "fileno", "(", ")", ",", "self", ".", "_on_io_events", ",", "ioloop", ".", "IOLoop", ".", "WRITE", ")" ]

[ "Create", "a", "new", "PostgreSQL", "connection" ]

[ "def", "_exec_cleanup", "(", "self", ",", "cursor", ",", "fd", ")", ":", "LOGGER", ".", "debug", "(", "'Closing cursor and cleaning %s'", ",", "fd", ")", "try", ":", "cursor", ".", "close", "(", ")", "except", "(", "psycopg2", ".", "Error", ",", "psycopg2", ".", "Warning", ")", "as", "error", ":", "LOGGER", ".", "debug", "(", "'Error closing the cursor: %s'", ",", "error", ")", "self", ".", "_cleanup_fd", "(", "fd", ")", "# If the cleanup callback exists, remove it", "if", "self", ".", "_cleanup_callback", ":", "self", ".", "_ioloop", ".", "remove_timeout", "(", "self", ".", "_cleanup_callback", ")", "# Create a new cleanup callback to clean the pool of idle connections", "self", ".", "_cleanup_callback", "=", "self", ".", "_ioloop", ".", "add_timeout", "(", "self", ".", "_ioloop", ".", "time", "(", ")", "+", "self", ".", "_pool_idle_ttl", "+", "1", ",", "self", ".", "_pool_manager", ".", "clean", ",", "self", ".", "pid", ")" ]

[ "Close", "the", "cursor", "remove", "any", "references", "to", "the", "fd", "in", "internal", "state", "and", "remove", "the", "fd", "from", "the", "ioloop", "." ]

[ "def", "_cleanup_fd", "(", "self", ",", "fd", ",", "close", "=", "False", ")", ":", "self", ".", "_ioloop", ".", "remove_handler", "(", "fd", ")", "if", "fd", "in", "self", ".", "_connections", ":", "try", ":", "self", ".", "_pool_manager", ".", "free", "(", "self", ".", "pid", ",", "self", ".", "_connections", "[", "fd", "]", ")", "except", "pool", ".", "ConnectionNotFoundError", ":", "pass", "if", "close", ":", "self", ".", "_connections", "[", "fd", "]", ".", "close", "(", ")", "del", "self", ".", "_connections", "[", "fd", "]", "if", "fd", "in", "self", ".", "_futures", ":", "del", "self", ".", "_futures", "[", "fd", "]" ]

[ "Ensure", "the", "socket", "socket", "is", "removed", "from", "the", "IOLoop", "the", "connection", "stack", "and", "futures", "stack", "." ]

[ "def", "_on_io_events", "(", "self", ",", "fd", "=", "None", ",", "_events", "=", "None", ")", ":", "if", "fd", "not", "in", "self", ".", "_connections", ":", "LOGGER", ".", "warning", "(", "'Received IO event for non-existing connection'", ")", "return", "self", ".", "_poll_connection", "(", "fd", ")" ]

[ "Invoked", "by", "Tornado", "s", "IOLoop", "when", "there", "are", "events", "for", "the", "fd" ]

[ "def", "_poll_connection", "(", "self", ",", "fd", ")", ":", "try", ":", "state", "=", "self", ".", "_connections", "[", "fd", "]", ".", "poll", "(", ")", "except", "(", "OSError", ",", "socket", ".", "error", ")", "as", "error", ":", "self", ".", "_ioloop", ".", "remove_handler", "(", "fd", ")", "if", "fd", "in", "self", ".", "_futures", "and", "not", "self", ".", "_futures", "[", "fd", "]", ".", "done", "(", ")", ":", "self", ".", "_futures", "[", "fd", "]", ".", "set_exception", "(", "psycopg2", ".", "OperationalError", "(", "'Connection error (%s)'", "%", "error", ")", ")", "except", "(", "psycopg2", ".", "Error", ",", "psycopg2", ".", "Warning", ")", "as", "error", ":", "if", "fd", "in", "self", ".", "_futures", "and", "not", "self", ".", "_futures", "[", "fd", "]", ".", "done", "(", ")", ":", "self", ".", "_futures", "[", "fd", "]", ".", "set_exception", "(", "error", ")", "else", ":", "if", "state", "==", "extensions", ".", "POLL_OK", ":", "if", "fd", "in", "self", ".", "_futures", "and", "not", "self", ".", "_futures", "[", "fd", "]", ".", "done", "(", ")", ":", "self", ".", "_futures", "[", "fd", "]", ".", "set_result", "(", "True", ")", "elif", "state", "==", "extensions", ".", "POLL_WRITE", ":", "self", ".", "_ioloop", ".", "update_handler", "(", "fd", ",", "ioloop", ".", "IOLoop", ".", "WRITE", ")", "elif", "state", "==", "extensions", ".", "POLL_READ", ":", "self", ".", "_ioloop", ".", "update_handler", "(", "fd", ",", "ioloop", ".", "IOLoop", ".", "READ", ")", "elif", "state", "==", "extensions", ".", "POLL_ERROR", ":", "self", ".", "_ioloop", ".", "remove_handler", "(", "fd", ")", "if", "fd", "in", "self", ".", "_futures", "and", "not", "self", ".", "_futures", "[", "fd", "]", ".", "done", "(", ")", ":", "self", ".", "_futures", "[", "fd", "]", ".", "set_exception", "(", "psycopg2", ".", "Error", "(", "'Poll Error'", ")", ")" ]

[ "Check", "with", "psycopg2", "to", "see", "what", "action", "to", "take", ".", "If", "the", "state", "is", "POLL_OK", "we", "should", "have", "a", "pending", "callback", "for", "that", "fd", "." ]

[ "def", "main", "(", ")", ":", "import", "codecs", "setuptools", ".", "setup", "(", "name", "=", "'wcwidth'", ",", "version", "=", "'0.1.7'", ",", "description", "=", "(", "\"Measures number of Terminal column cells \"", "\"of wide-character codes\"", ")", ",", "long_description", "=", "codecs", ".", "open", "(", "os", ".", "path", ".", "join", "(", "HERE", ",", "'README.rst'", ")", ",", "'r'", ",", "'utf8'", ")", ".", "read", "(", ")", ",", "author", "=", "'Jeff Quast'", ",", "author_email", "=", "'[email protected]'", ",", "license", "=", "'MIT'", ",", "packages", "=", "[", "'wcwidth'", ",", "'wcwidth.tests'", "]", ",", "url", "=", "'https://github.com/jquast/wcwidth'", ",", "include_package_data", "=", "True", ",", "test_suite", "=", "'wcwidth.tests'", ",", "zip_safe", "=", "True", ",", "classifiers", "=", "[", "'Intended Audience :: Developers'", ",", "'Natural Language :: English'", ",", "'Development Status :: 3 - Alpha'", ",", "'Environment :: Console'", ",", "'License :: OSI Approved :: MIT License'", ",", "'Operating System :: POSIX'", ",", "'Programming Language :: Python :: 2.7'", ",", "'Programming Language :: Python :: 3.4'", ",", "'Programming Language :: Python :: 3.5'", ",", "'Topic :: Software Development :: Libraries'", ",", "'Topic :: Software Development :: Localization'", ",", "'Topic :: Software Development :: Internationalization'", ",", "'Topic :: Terminals'", "]", ",", "keywords", "=", "[", "'terminal'", ",", "'emulator'", ",", "'wcwidth'", ",", "'wcswidth'", ",", "'cjk'", ",", "'combining'", ",", "'xterm'", ",", "'console'", ",", "]", ",", "cmdclass", "=", "{", "'update'", ":", "SetupUpdate", "}", ",", ")" ]

[ "Setup", ".", "py", "entry", "point", "." ]

[ "def", "_do_readme_update", "(", "self", ")", ":", "import", "codecs", "import", "glob", "# read in,", "data_in", "=", "codecs", ".", "open", "(", "os", ".", "path", ".", "join", "(", "HERE", ",", "'README.rst'", ")", ",", "'r'", ",", "'utf8'", ")", ".", "read", "(", ")", "# search for beginning and end positions,", "pos_begin", "=", "data_in", ".", "find", "(", "self", ".", "README_PATCH_FROM", ")", "assert", "pos_begin", "!=", "-", "1", ",", "(", "pos_begin", ",", "self", ".", "README_PATCH_FROM", ")", "pos_begin", "+=", "len", "(", "self", ".", "README_PATCH_FROM", ")", "pos_end", "=", "data_in", ".", "find", "(", "self", ".", "README_PATCH_TO", ")", "assert", "pos_end", "!=", "-", "1", ",", "(", "pos_end", ",", "self", ".", "README_PATCH_TO", ")", "glob_pattern", "=", "os", ".", "path", ".", "join", "(", "HERE", ",", "'data'", ",", "'*.txt'", ")", "file_descriptions", "=", "[", "self", ".", "_describe_file_header", "(", "fpath", ")", "for", "fpath", "in", "glob", ".", "glob", "(", "glob_pattern", ")", "]", "# patch,", "data_out", "=", "(", "data_in", "[", ":", "pos_begin", "]", "+", "'\\n\\n'", "+", "'\\n'", ".", "join", "(", "file_descriptions", ")", "+", "'\\n\\n'", "+", "data_in", "[", "pos_end", ":", "]", ")", "# write.", "print", "(", "\"patching {} ..\"", ".", "format", "(", "self", ".", "README_RST", ")", ")", "codecs", ".", "open", "(", "self", ".", "README_RST", ",", "'w'", ",", "'utf8'", ")", ".", "write", "(", "data_out", ")" ]

[ "Patch", "README", ".", "rst", "to", "reflect", "the", "data", "files", "used", "in", "release", "." ]

[ "def", "_do_east_asian", "(", "self", ")", ":", "self", ".", "_do_retrieve", "(", "self", ".", "EAW_URL", ",", "self", ".", "EAW_IN", ")", "(", "version", ",", "date", ",", "values", ")", "=", "self", ".", "_parse_east_asian", "(", "fname", "=", "self", ".", "EAW_IN", ",", "properties", "=", "(", "u'W'", ",", "u'F'", ",", ")", ")", "table", "=", "self", ".", "_make_table", "(", "values", ")", "self", ".", "_do_write", "(", "self", ".", "EAW_OUT", ",", "'WIDE_EASTASIAN'", ",", "version", ",", "date", ",", "table", ")" ]

[ "Fetch", "and", "update", "east", "-", "asian", "tables", "." ]

[ "def", "_do_zero_width", "(", "self", ")", ":", "self", ".", "_do_retrieve", "(", "self", ".", "UCD_URL", ",", "self", ".", "UCD_IN", ")", "(", "version", ",", "date", ",", "values", ")", "=", "self", ".", "_parse_category", "(", "fname", "=", "self", ".", "UCD_IN", ",", "categories", "=", "(", "'Me'", ",", "'Mn'", ",", ")", ")", "table", "=", "self", ".", "_make_table", "(", "values", ")", "self", ".", "_do_write", "(", "self", ".", "ZERO_OUT", ",", "'ZERO_WIDTH'", ",", "version", ",", "date", ",", "table", ")" ]

[ "Fetch", "and", "update", "zero", "width", "tables", "." ]

[ "def", "_make_table", "(", "values", ")", ":", "import", "collections", "table", "=", "collections", ".", "deque", "(", ")", "start", ",", "end", "=", "values", "[", "0", "]", ",", "values", "[", "0", "]", "for", "num", ",", "value", "in", "enumerate", "(", "values", ")", ":", "if", "num", "==", "0", ":", "table", ".", "append", "(", "(", "value", ",", "value", ",", ")", ")", "continue", "start", ",", "end", "=", "table", ".", "pop", "(", ")", "if", "end", "==", "value", "-", "1", ":", "table", ".", "append", "(", "(", "start", ",", "value", ",", ")", ")", "else", ":", "table", ".", "append", "(", "(", "start", ",", "end", ",", ")", ")", "table", ".", "append", "(", "(", "value", ",", "value", ",", ")", ")", "return", "tuple", "(", "table", ")" ]

[ "Return", "a", "tuple", "of", "lookup", "tables", "for", "given", "values", "." ]

[ "def", "_do_retrieve", "(", "url", ",", "fname", ")", ":", "folder", "=", "os", ".", "path", ".", "dirname", "(", "fname", ")", "if", "not", "os", ".", "path", ".", "exists", "(", "folder", ")", ":", "os", ".", "makedirs", "(", "folder", ")", "print", "(", "\"{}/ created.\"", ".", "format", "(", "folder", ")", ")", "if", "not", "os", ".", "path", ".", "exists", "(", "fname", ")", ":", "with", "open", "(", "fname", ",", "'wb'", ")", "as", "fout", ":", "print", "(", "\"retrieving {}.\"", ".", "format", "(", "url", ")", ")", "resp", "=", "urlopen", "(", "url", ")", "fout", ".", "write", "(", "resp", ".", "read", "(", ")", ")", "print", "(", "\"{} saved.\"", ".", "format", "(", "fname", ")", ")", "else", ":", "print", "(", "\"re-using artifact {}\"", ".", "format", "(", "fname", ")", ")", "return", "fname" ]

[ "Retrieve", "given", "url", "to", "target", "filepath", "fname", "." ]

[ "def", "_parse_east_asian", "(", "fname", ",", "properties", "=", "(", "u'W'", ",", "u'F'", ",", ")", ")", ":", "version", ",", "date", ",", "values", "=", "None", ",", "None", ",", "[", "]", "print", "(", "\"parsing {} ..\"", ".", "format", "(", "fname", ")", ")", "for", "line", "in", "open", "(", "fname", ",", "'rb'", ")", ":", "uline", "=", "line", ".", "decode", "(", "'utf-8'", ")", "if", "version", "is", "None", ":", "version", "=", "uline", ".", "split", "(", "None", ",", "1", ")", "[", "1", "]", ".", "rstrip", "(", ")", "continue", "elif", "date", "is", "None", ":", "date", "=", "uline", ".", "split", "(", "':'", ",", "1", ")", "[", "1", "]", ".", "rstrip", "(", ")", "continue", "if", "uline", ".", "startswith", "(", "'#'", ")", "or", "not", "uline", ".", "lstrip", "(", ")", ":", "continue", "addrs", ",", "details", "=", "uline", ".", "split", "(", "';'", ",", "1", ")", "if", "any", "(", "details", ".", "startswith", "(", "property", ")", "for", "property", "in", "properties", ")", ":", "start", ",", "stop", "=", "addrs", ",", "addrs", "if", "'..'", "in", "addrs", ":", "start", ",", "stop", "=", "addrs", ".", "split", "(", "'..'", ")", "values", ".", "extend", "(", "range", "(", "int", "(", "start", ",", "16", ")", ",", "int", "(", "stop", ",", "16", ")", "+", "1", ")", ")", "return", "version", ",", "date", ",", "sorted", "(", "values", ")" ]

[ "Parse", "unicode", "east", "-", "asian", "width", "tables", "." ]

[ "def", "_parse_category", "(", "fname", ",", "categories", ")", ":", "version", ",", "date", ",", "values", "=", "None", ",", "None", ",", "[", "]", "print", "(", "\"parsing {} ..\"", ".", "format", "(", "fname", ")", ")", "for", "line", "in", "open", "(", "fname", ",", "'rb'", ")", ":", "uline", "=", "line", ".", "decode", "(", "'utf-8'", ")", "if", "version", "is", "None", ":", "version", "=", "uline", ".", "split", "(", "None", ",", "1", ")", "[", "1", "]", ".", "rstrip", "(", ")", "continue", "elif", "date", "is", "None", ":", "date", "=", "uline", ".", "split", "(", "':'", ",", "1", ")", "[", "1", "]", ".", "rstrip", "(", ")", "continue", "if", "uline", ".", "startswith", "(", "'#'", ")", "or", "not", "uline", ".", "lstrip", "(", ")", ":", "continue", "addrs", ",", "details", "=", "uline", ".", "split", "(", "';'", ",", "1", ")", "addrs", ",", "details", "=", "addrs", ".", "rstrip", "(", ")", ",", "details", ".", "lstrip", "(", ")", "if", "any", "(", "details", ".", "startswith", "(", "'{} #'", ".", "format", "(", "value", ")", ")", "for", "value", "in", "categories", ")", ":", "start", ",", "stop", "=", "addrs", ",", "addrs", "if", "'..'", "in", "addrs", ":", "start", ",", "stop", "=", "addrs", ".", "split", "(", "'..'", ")", "values", ".", "extend", "(", "range", "(", "int", "(", "start", ",", "16", ")", ",", "int", "(", "stop", ",", "16", ")", "+", "1", ")", ")", "return", "version", ",", "date", ",", "sorted", "(", "values", ")" ]

[ "Parse", "unicode", "category", "tables", "." ]

[ "def", "_do_write", "(", "fname", ",", "variable", ",", "version", ",", "date", ",", "table", ")", ":", "# pylint: disable=R0914", "# Too many local variables (19/15) (col 4)", "print", "(", "\"writing {} ..\"", ".", "format", "(", "fname", ")", ")", "import", "unicodedata", "import", "datetime", "import", "string", "utc_now", "=", "datetime", ".", "datetime", ".", "utcnow", "(", ")", "indent", "=", "4", "with", "open", "(", "fname", ",", "'w'", ")", "as", "fout", ":", "fout", ".", "write", "(", "'\"\"\"{variable_proper} table. Created by setup.py.\"\"\"\\n'", "\"# Generated: {iso_utc}\\n\"", "\"# Source: {version}\\n\"", "\"# Date: {date}\\n\"", "\"{variable} = (\"", ".", "format", "(", "iso_utc", "=", "utc_now", ".", "isoformat", "(", ")", ",", "version", "=", "version", ",", "date", "=", "date", ",", "variable", "=", "variable", ",", "variable_proper", "=", "variable", ".", "title", "(", ")", ")", ")", "for", "start", ",", "end", "in", "table", ":", "ucs_start", ",", "ucs_end", "=", "unichr", "(", "start", ")", ",", "unichr", "(", "end", ")", "hex_start", ",", "hex_end", "=", "(", "'0x{0:04x}'", ".", "format", "(", "start", ")", ",", "'0x{0:04x}'", ".", "format", "(", "end", ")", ")", "try", ":", "name_start", "=", "string", ".", "capwords", "(", "unicodedata", ".", "name", "(", "ucs_start", ")", ")", "except", "ValueError", ":", "name_start", "=", "u''", "try", ":", "name_end", "=", "string", ".", "capwords", "(", "unicodedata", ".", "name", "(", "ucs_end", ")", ")", "except", "ValueError", ":", "name_end", "=", "u''", "fout", ".", "write", "(", "'\\n'", "+", "(", "' '", "*", "indent", ")", ")", "fout", ".", "write", "(", "'({0}, {1},),'", ".", "format", "(", "hex_start", ",", "hex_end", ")", ")", "fout", ".", "write", "(", "' # {0:24s}..{1}'", ".", "format", "(", "name_start", "[", ":", "24", "]", ".", "rstrip", "(", ")", "or", "'(nil)'", ",", "name_end", "[", ":", "24", "]", ".", "rstrip", "(", ")", ")", ")", "fout", ".", "write", "(", "'\\n)\\n'", ")", "print", "(", "\"complete.\"", ")" ]

[ "Write", "combining", "tables", "to", "filesystem", "as", "python", "code", "." ]

[ "def", "report_ucs_msg", "(", "ucs", ",", "wcwidth_libc", ",", "wcwidth_local", ")", ":", "ucp", "=", "(", "ucs", ".", "encode", "(", "'unicode_escape'", ")", "[", "2", ":", "]", ".", "decode", "(", "'ascii'", ")", ".", "upper", "(", ")", ".", "lstrip", "(", "'0'", ")", ")", "url", "=", "\"http://codepoints.net/U+{}\"", ".", "format", "(", "ucp", ")", "name", "=", "unicodedata", ".", "name", "(", "ucs", ")", "return", "(", "u\"libc,ours={},{} [--o{}o--] name={} val={} {}\"", "\" \"", ".", "format", "(", "wcwidth_libc", ",", "wcwidth_local", ",", "ucs", ",", "name", ",", "ord", "(", "ucs", ")", ",", "url", ")", ")" ]

[ "Return", "string", "report", "of", "combining", "character", "differences", "." ]

[ "def", "validate_args", "(", "opts", ")", ":", "if", "opts", "[", "'--wide'", "]", "is", "None", ":", "opts", "[", "'--wide'", "]", "=", "2", "else", ":", "assert", "opts", "[", "'--wide'", "]", "in", "(", "\"1\"", ",", "\"2\"", ")", ",", "opts", "[", "'--wide'", "]", "if", "opts", "[", "'--alignment'", "]", "is", "None", ":", "opts", "[", "'--alignment'", "]", "=", "'left'", "else", ":", "assert", "opts", "[", "'--alignment'", "]", "in", "(", "'left'", ",", "'right'", ")", ",", "opts", "[", "'--alignment'", "]", "opts", "[", "'--wide'", "]", "=", "int", "(", "opts", "[", "'--wide'", "]", ")", "opts", "[", "'character_factory'", "]", "=", "WcWideCharacterGenerator", "if", "opts", "[", "'--combining'", "]", ":", "opts", "[", "'character_factory'", "]", "=", "WcCombinedCharacterGenerator", "return", "opts" ]

[ "Validate", "and", "return", "options", "provided", "by", "docopt", "parsing", "." ]

[ "def", "hint_width", "(", "self", ")", ":", "return", "sum", "(", "(", "len", "(", "self", ".", "style", ".", "delimiter", ")", ",", "self", ".", "wide", ",", "len", "(", "self", ".", "style", ".", "delimiter", ")", ",", "len", "(", "u' '", ")", ",", "UCS_PRINTLEN", "+", "2", ",", "len", "(", "u' '", ")", ",", "self", ".", "style", ".", "name_len", ",", ")", ")" ]

[ "Width", "of", "a", "column", "segment", "." ]

[ "def", "head_item", "(", "self", ")", ":", "delimiter", "=", "self", ".", "style", ".", "attr_minor", "(", "self", ".", "style", ".", "delimiter", ")", "hint", "=", "self", ".", "style", ".", "header_hint", "*", "self", ".", "wide", "heading", "=", "(", "u'{delimiter}{hint}{delimiter}'", ".", "format", "(", "delimiter", "=", "delimiter", ",", "hint", "=", "hint", ")", ")", "alignment", "=", "lambda", "*", "args", ":", "(", "self", ".", "term", ".", "rjust", "(", "*", "args", ")", "if", "self", ".", "style", ".", "alignment", "==", "'right'", "else", "self", ".", "term", ".", "ljust", "(", "*", "args", ")", ")", "txt", "=", "alignment", "(", "heading", ",", "self", ".", "hint_width", ",", "self", ".", "style", ".", "header_fill", ")", "return", "self", ".", "style", ".", "attr_major", "(", "txt", ")" ]

[ "Text", "of", "a", "single", "column", "heading", "." ]

[ "def", "msg_intro", "(", "self", ")", ":", "delim", "=", "self", ".", "style", ".", "attr_minor", "(", "self", ".", "style", ".", "delimiter", ")", "txt", "=", "self", ".", "intro_msg_fmt", ".", "format", "(", "delim", "=", "delim", ")", ".", "rstrip", "(", ")", "return", "self", ".", "term", ".", "center", "(", "txt", ")" ]

[ "Introductory", "message", "disabled", "above", "heading", "." ]

[ "def", "num_columns", "(", "self", ")", ":", "if", "self", ".", "term", ".", "is_a_tty", ":", "return", "self", ".", "term", ".", "width", "//", "self", ".", "hint_width", "return", "1" ]

[ "Number", "of", "columns", "displayed", "." ]

[ "def", "on_resize", "(", "self", ",", "*", "args", ")", ":", "# pylint: disable=W0613", "# Unused argument 'args'", "self", ".", "screen", ".", "style", ".", "name_len", "=", "min", "(", "self", ".", "screen", ".", "style", ".", "name_len", ",", "self", ".", "term", ".", "width", "-", "15", ")", "assert", "self", ".", "term", ".", "width", ">=", "self", ".", "screen", ".", "hint_width", ",", "(", "'Screen to small {}, must be at least {}'", ".", "format", "(", "self", ".", "term", ".", "width", ",", "self", ".", "screen", ".", "hint_width", ")", ")", "self", ".", "_set_lastpage", "(", ")", "self", ".", "dirty", "=", "self", ".", "STATE_REFRESH" ]

[ "Signal", "handler", "callback", "for", "SIGWINCH", "." ]

[ "def", "_set_lastpage", "(", "self", ")", ":", "self", ".", "last_page", "=", "(", "len", "(", "self", ".", "_page_data", ")", "-", "1", ")", "//", "self", ".", "screen", ".", "page_size" ]

[ "Calculate", "value", "of", "class", "attribute", "last_page", "." ]

[ "def", "display_initialize", "(", "self", ")", ":", "echo", "(", "self", ".", "term", ".", "home", "+", "self", ".", "term", ".", "clear", ")", "echo", "(", "self", ".", "term", ".", "move_y", "(", "self", ".", "term", ".", "height", "//", "2", ")", ")", "echo", "(", "self", ".", "term", ".", "center", "(", "'Initializing page data ...'", ")", ".", "rstrip", "(", ")", ")", "flushout", "(", ")", "if", "LIMIT_UCS", "==", "0x10000", ":", "echo", "(", "'\\n\\n'", ")", "echo", "(", "self", ".", "term", ".", "blink_red", "(", "self", ".", "term", ".", "center", "(", "'narrow Python build: upperbound value is {n}.'", ".", "format", "(", "n", "=", "LIMIT_UCS", ")", ")", ".", "rstrip", "(", ")", ")", ")", "echo", "(", "'\\n\\n'", ")", "flushout", "(", ")" ]

[ "Display", "please", "wait", "message", "and", "narrow", "build", "warning", "." ]

[ "def", "initialize_page_data", "(", "self", ")", ":", "if", "self", ".", "term", ".", "is_a_tty", ":", "self", ".", "display_initialize", "(", ")", "self", ".", "character_generator", "=", "self", ".", "character_factory", "(", "self", ".", "screen", ".", "wide", ")", "page_data", "=", "list", "(", ")", "while", "True", ":", "try", ":", "page_data", ".", "append", "(", "next", "(", "self", ".", "character_generator", ")", ")", "except", "StopIteration", ":", "break", "if", "LIMIT_UCS", "==", "0x10000", ":", "echo", "(", "self", ".", "term", ".", "center", "(", "'press any key.'", ")", ".", "rstrip", "(", ")", ")", "flushout", "(", ")", "self", ".", "term", ".", "inkey", "(", "timeout", "=", "None", ")", "return", "page_data" ]

[ "Initialize", "the", "page", "data", "for", "the", "given", "screen", "." ]

[ "def", "page_data", "(", "self", ",", "idx", ",", "offset", ")", ":", "size", "=", "self", ".", "screen", ".", "page_size", "while", "offset", "<", "0", "and", "idx", ":", "offset", "+=", "size", "idx", "-=", "1", "offset", "=", "max", "(", "0", ",", "offset", ")", "while", "offset", ">=", "size", ":", "offset", "-=", "size", "idx", "+=", "1", "if", "idx", "==", "self", ".", "last_page", ":", "offset", "=", "0", "idx", "=", "min", "(", "max", "(", "0", ",", "idx", ")", ",", "self", ".", "last_page", ")", "start", "=", "(", "idx", "*", "self", ".", "screen", ".", "page_size", ")", "+", "offset", "end", "=", "start", "+", "self", ".", "screen", ".", "page_size", "return", "(", "idx", ",", "offset", ")", ",", "self", ".", "_page_data", "[", "start", ":", "end", "]" ]

[ "Return", "character", "data", "for", "page", "of", "given", "index", "and", "offset", "." ]

[ "def", "_run_notty", "(", "self", ",", "writer", ")", ":", "page_idx", "=", "page_offset", "=", "0", "while", "True", ":", "npage_idx", ",", "_", "=", "self", ".", "draw", "(", "writer", ",", "page_idx", "+", "1", ",", "page_offset", ")", "if", "npage_idx", "==", "self", ".", "last_page", ":", "# page displayed was last page, quit.", "break", "page_idx", "=", "npage_idx", "self", ".", "dirty", "=", "self", ".", "STATE_DIRTY", "return" ]

[ "Pager", "run", "method", "for", "terminals", "that", "are", "not", "a", "tty", "." ]

[ "def", "_run_tty", "(", "self", ",", "writer", ",", "reader", ")", ":", "# allow window-change signal to reflow screen", "signal", ".", "signal", "(", "signal", ".", "SIGWINCH", ",", "self", ".", "on_resize", ")", "page_idx", "=", "page_offset", "=", "0", "while", "True", ":", "if", "self", ".", "dirty", ":", "page_idx", ",", "page_offset", "=", "self", ".", "draw", "(", "writer", ",", "page_idx", ",", "page_offset", ")", "self", ".", "dirty", "=", "self", ".", "STATE_CLEAN", "inp", "=", "reader", "(", "timeout", "=", "0.25", ")", "if", "inp", "is", "not", "None", ":", "nxt", ",", "noff", "=", "self", ".", "process_keystroke", "(", "inp", ",", "page_idx", ",", "page_offset", ")", "if", "not", "self", ".", "dirty", ":", "self", ".", "dirty", "=", "nxt", "!=", "page_idx", "or", "noff", "!=", "page_offset", "page_idx", ",", "page_offset", "=", "nxt", ",", "noff", "if", "page_idx", "==", "-", "1", ":", "return" ]

[ "Pager", "run", "method", "for", "terminals", "that", "are", "a", "tty", "." ]

[ "def", "run", "(", "self", ",", "writer", ",", "reader", ")", ":", "self", ".", "_page_data", "=", "self", ".", "initialize_page_data", "(", ")", "self", ".", "_set_lastpage", "(", ")", "if", "not", "self", ".", "term", ".", "is_a_tty", ":", "self", ".", "_run_notty", "(", "writer", ")", "else", ":", "self", ".", "_run_tty", "(", "writer", ",", "reader", ")" ]

[ "Pager", "entry", "point", "." ]

[ "def", "process_keystroke", "(", "self", ",", "inp", ",", "idx", ",", "offset", ")", ":", "if", "inp", ".", "lower", "(", ")", "in", "(", "u'q'", ",", "u'Q'", ")", ":", "# exit", "return", "(", "-", "1", ",", "-", "1", ")", "self", ".", "_process_keystroke_commands", "(", "inp", ")", "idx", ",", "offset", "=", "self", ".", "_process_keystroke_movement", "(", "inp", ",", "idx", ",", "offset", ")", "return", "idx", ",", "offset" ]

[ "Process", "keystroke", "inp", "adjusting", "screen", "parameters", "." ]

[ "def", "_process_keystroke_movement", "(", "self", ",", "inp", ",", "idx", ",", "offset", ")", ":", "term", "=", "self", ".", "term", "if", "inp", "in", "(", "u'y'", ",", "u'k'", ")", "or", "inp", ".", "code", "in", "(", "term", ".", "KEY_UP", ",", ")", ":", "# scroll backward 1 line", "idx", ",", "offset", "=", "(", "idx", ",", "offset", "-", "self", ".", "screen", ".", "num_columns", ")", "elif", "inp", "in", "(", "u'e'", ",", "u'j'", ")", "or", "inp", ".", "code", "in", "(", "term", ".", "KEY_ENTER", ",", "term", ".", "KEY_DOWN", ",", ")", ":", "# scroll forward 1 line", "idx", ",", "offset", "=", "(", "idx", ",", "offset", "+", "self", ".", "screen", ".", "num_columns", ")", "elif", "inp", "in", "(", "u'f'", ",", "u' '", ")", "or", "inp", ".", "code", "in", "(", "term", ".", "KEY_PGDOWN", ",", ")", ":", "# scroll forward 1 page", "idx", ",", "offset", "=", "(", "idx", "+", "1", ",", "offset", ")", "elif", "inp", "==", "u'b'", "or", "inp", ".", "code", "in", "(", "term", ".", "KEY_PGUP", ",", ")", ":", "# scroll backward 1 page", "idx", ",", "offset", "=", "(", "max", "(", "0", ",", "idx", "-", "1", ")", ",", "offset", ")", "elif", "inp", ".", "code", "in", "(", "term", ".", "KEY_SDOWN", ",", ")", ":", "# scroll forward 10 pages", "idx", ",", "offset", "=", "(", "max", "(", "0", ",", "idx", "+", "10", ")", ",", "offset", ")", "elif", "inp", ".", "code", "in", "(", "term", ".", "KEY_SUP", ",", ")", ":", "# scroll forward 10 pages", "idx", ",", "offset", "=", "(", "max", "(", "0", ",", "idx", "-", "10", ")", ",", "offset", ")", "elif", "inp", ".", "code", "==", "term", ".", "KEY_HOME", ":", "# top", "idx", ",", "offset", "=", "(", "0", ",", "0", ")", "elif", "inp", ".", "code", "==", "term", ".", "KEY_END", ":", "# bottom", "idx", ",", "offset", "=", "(", "self", ".", "last_page", ",", "0", ")", "return", "idx", ",", "offset" ]

[ "Process", "keystrokes", "that", "adjust", "index", "and", "offset", "." ]

[ "def", "draw", "(", "self", ",", "writer", ",", "idx", ",", "offset", ")", ":", "# as our screen can be resized while we're mid-calculation,", "# our self.dirty flag can become re-toggled; because we are", "# not re-flowing our pagination, we must begin over again.", "while", "self", ".", "dirty", ":", "self", ".", "draw_heading", "(", "writer", ")", "self", ".", "dirty", "=", "self", ".", "STATE_CLEAN", "(", "idx", ",", "offset", ")", ",", "data", "=", "self", ".", "page_data", "(", "idx", ",", "offset", ")", "for", "txt", "in", "self", ".", "page_view", "(", "data", ")", ":", "writer", "(", "txt", ")", "self", ".", "draw_status", "(", "writer", ",", "idx", ")", "flushout", "(", ")", "return", "idx", ",", "offset" ]

[ "Draw", "the", "current", "page", "view", "to", "writer", "." ]

[ "def", "draw_heading", "(", "self", ",", "writer", ")", ":", "if", "self", ".", "dirty", "==", "self", ".", "STATE_REFRESH", ":", "writer", "(", "u''", ".", "join", "(", "(", "self", ".", "term", ".", "home", ",", "self", ".", "term", ".", "clear", ",", "self", ".", "screen", ".", "msg_intro", ",", "'\\n'", ",", "self", ".", "screen", ".", "header", ",", "'\\n'", ",", ")", ")", ")", "return", "True" ]

[ "Conditionally", "redraw", "screen", "when", "dirty", "attribute", "is", "valued", "REFRESH", "." ]

[ "def", "draw_status", "(", "self", ",", "writer", ",", "idx", ")", ":", "if", "self", ".", "term", ".", "is_a_tty", ":", "writer", "(", "self", ".", "term", ".", "hide_cursor", "(", ")", ")", "style", "=", "self", ".", "screen", ".", "style", "writer", "(", "self", ".", "term", ".", "move", "(", "self", ".", "term", ".", "height", "-", "1", ")", ")", "if", "idx", "==", "self", ".", "last_page", ":", "last_end", "=", "u'(END)'", "else", ":", "last_end", "=", "u'/{0}'", ".", "format", "(", "self", ".", "last_page", ")", "txt", "=", "(", "u'Page {idx}{last_end} - '", "u'{q} to quit, [keys: {keyset}]'", ".", "format", "(", "idx", "=", "style", ".", "attr_minor", "(", "u'{0}'", ".", "format", "(", "idx", ")", ")", ",", "last_end", "=", "style", ".", "attr_major", "(", "last_end", ")", ",", "keyset", "=", "style", ".", "attr_major", "(", "'kjfb12-='", ")", ",", "q", "=", "style", ".", "attr_minor", "(", "u'q'", ")", ")", ")", "writer", "(", "self", ".", "term", ".", "center", "(", "txt", ")", ".", "rstrip", "(", ")", ")" ]

[ "Conditionally", "draw", "status", "bar", "when", "output", "terminal", "is", "a", "tty", "." ]

[ "def", "page_view", "(", "self", ",", "data", ")", ":", "if", "self", ".", "term", ".", "is_a_tty", ":", "yield", "self", ".", "term", ".", "move", "(", "self", ".", "screen", ".", "row_begins", ",", "0", ")", "# sequence clears to end-of-line", "clear_eol", "=", "self", ".", "term", ".", "clear_eol", "# sequence clears to end-of-screen", "clear_eos", "=", "self", ".", "term", ".", "clear_eos", "# track our current column and row, where column is", "# the whole segment of unicode value text, and draw", "# only self.screen.num_columns before end-of-line.", "#", "# use clear_eol at end of each row to erase over any", "# \"ghosted\" text, and clear_eos at end of screen to", "# clear the same, especially for the final page which", "# is often short.", "col", "=", "0", "for", "ucs", ",", "name", "in", "data", ":", "val", "=", "self", ".", "text_entry", "(", "ucs", ",", "name", ")", "col", "+=", "1", "if", "col", "==", "self", ".", "screen", ".", "num_columns", ":", "col", "=", "0", "if", "self", ".", "term", ".", "is_a_tty", ":", "val", "=", "u''", ".", "join", "(", "(", "val", ",", "clear_eol", ",", "u'\\n'", ")", ")", "else", ":", "val", "=", "u''", ".", "join", "(", "(", "val", ".", "rstrip", "(", ")", ",", "u'\\n'", ")", ")", "yield", "val", "if", "self", ".", "term", ".", "is_a_tty", ":", "yield", "u''", ".", "join", "(", "(", "clear_eol", ",", "u'\\n'", ",", "clear_eos", ")", ")" ]

[ "Generator", "yields", "text", "to", "be", "displayed", "for", "the", "current", "unicode", "pageview", "." ]

[ "def", "back_tick", "(", "cmd", ",", "ret_err", "=", "False", ",", "as_str", "=", "True", ",", "raise_err", "=", "None", ")", ":", "if", "raise_err", "is", "None", ":", "raise_err", "=", "False", "if", "ret_err", "else", "True", "cmd_is_seq", "=", "isinstance", "(", "cmd", ",", "(", "list", ",", "tuple", ")", ")", "proc", "=", "Popen", "(", "cmd", ",", "stdout", "=", "PIPE", ",", "stderr", "=", "PIPE", ",", "shell", "=", "not", "cmd_is_seq", ")", "out", ",", "err", "=", "proc", ".", "communicate", "(", ")", "retcode", "=", "proc", ".", "returncode", "cmd_str", "=", "' '", ".", "join", "(", "cmd", ")", "if", "cmd_is_seq", "else", "cmd", "if", "retcode", "is", "None", ":", "proc", ".", "terminate", "(", ")", "raise", "RuntimeError", "(", "cmd_str", "+", "' process did not terminate'", ")", "if", "raise_err", "and", "retcode", "!=", "0", ":", "raise", "RuntimeError", "(", "'{0} returned code {1} with error {2}'", ".", "format", "(", "cmd_str", ",", "retcode", ",", "err", ".", "decode", "(", "'latin-1'", ")", ")", ")", "out", "=", "out", ".", "strip", "(", ")", "if", "as_str", ":", "out", "=", "out", ".", "decode", "(", "'latin-1'", ")", "if", "not", "ret_err", ":", "return", "out", "err", "=", "err", ".", "strip", "(", ")", "if", "as_str", ":", "err", "=", "err", ".", "decode", "(", "'latin-1'", ")", "return", "out", ",", "err" ]

[ "Run", "command", "cmd", "return", "stdout", "or", "stdout", "stderr", "if", "ret_err" ]

[ "def", "unique_by_index", "(", "sequence", ")", ":", "uniques", "=", "[", "]", "for", "element", "in", "sequence", ":", "if", "element", "not", "in", "uniques", ":", "uniques", ".", "append", "(", "element", ")", "return", "uniques" ]

[ "unique", "elements", "in", "sequence", "in", "the", "order", "in", "which", "they", "occur" ]

[ "def", "ensure_permissions", "(", "mode_flags", "=", "stat", ".", "S_IWUSR", ")", ":", "def", "decorator", "(", "f", ")", ":", "def", "modify", "(", "filename", ",", "*", "args", ",", "*", "*", "kwargs", ")", ":", "m", "=", "chmod_perms", "(", "filename", ")", "if", "exists", "(", "filename", ")", "else", "mode_flags", "if", "not", "m", "&", "mode_flags", ":", "os", ".", "chmod", "(", "filename", ",", "m", "|", "mode_flags", ")", "try", ":", "return", "f", "(", "filename", ",", "*", "args", ",", "*", "*", "kwargs", ")", "finally", ":", "# restore original permissions", "if", "not", "m", "&", "mode_flags", ":", "os", ".", "chmod", "(", "filename", ",", "m", ")", "return", "modify", "return", "decorator" ]

[ "decorator", "to", "ensure", "a", "filename", "has", "given", "permissions", "." ]

[ "def", "get_install_names", "(", "filename", ")", ":", "lines", "=", "_cmd_out_err", "(", "[", "'otool'", ",", "'-L'", ",", "filename", "]", ")", "if", "not", "_line0_says_object", "(", "lines", "[", "0", "]", ",", "filename", ")", ":", "return", "(", ")", "names", "=", "tuple", "(", "parse_install_name", "(", "line", ")", "[", "0", "]", "for", "line", "in", "lines", "[", "1", ":", "]", ")", "install_id", "=", "get_install_id", "(", "filename", ")", "if", "not", "install_id", "is", "None", ":", "assert", "names", "[", "0", "]", "==", "install_id", "return", "names", "[", "1", ":", "]", "return", "names" ]

[ "Return", "install", "names", "from", "library", "named", "in", "filename" ]

[ "def", "get_install_id", "(", "filename", ")", ":", "lines", "=", "_cmd_out_err", "(", "[", "'otool'", ",", "'-D'", ",", "filename", "]", ")", "if", "not", "_line0_says_object", "(", "lines", "[", "0", "]", ",", "filename", ")", ":", "return", "None", "if", "len", "(", "lines", ")", "==", "1", ":", "return", "None", "if", "len", "(", "lines", ")", "!=", "2", ":", "raise", "InstallNameError", "(", "'Unexpected otool output '", "+", "'\\n'", ".", "join", "(", "lines", ")", ")", "return", "lines", "[", "1", "]", ".", "strip", "(", ")" ]

[ "Return", "install", "id", "from", "library", "named", "in", "filename" ]

[ "def", "set_install_name", "(", "filename", ",", "oldname", ",", "newname", ")", ":", "names", "=", "get_install_names", "(", "filename", ")", "if", "oldname", "not", "in", "names", ":", "raise", "InstallNameError", "(", "'{0} not in install names for {1}'", ".", "format", "(", "oldname", ",", "filename", ")", ")", "back_tick", "(", "[", "'install_name_tool'", ",", "'-change'", ",", "oldname", ",", "newname", ",", "filename", "]", ")" ]

[ "Set", "install", "name", "oldname", "to", "newname", "in", "library", "filename" ]

[ "def", "set_install_id", "(", "filename", ",", "install_id", ")", ":", "if", "get_install_id", "(", "filename", ")", "is", "None", ":", "raise", "InstallNameError", "(", "'{0} has no install id'", ".", "format", "(", "filename", ")", ")", "back_tick", "(", "[", "'install_name_tool'", ",", "'-id'", ",", "install_id", ",", "filename", "]", ")" ]

[ "Set", "install", "id", "for", "library", "named", "in", "filename" ]

[ "def", "get_rpaths", "(", "filename", ")", ":", "try", ":", "lines", "=", "_cmd_out_err", "(", "[", "'otool'", ",", "'-l'", ",", "filename", "]", ")", "except", "RuntimeError", ":", "return", "(", ")", "if", "not", "_line0_says_object", "(", "lines", "[", "0", "]", ",", "filename", ")", ":", "return", "(", ")", "lines", "=", "[", "line", ".", "strip", "(", ")", "for", "line", "in", "lines", "]", "paths", "=", "[", "]", "line_no", "=", "1", "while", "line_no", "<", "len", "(", "lines", ")", ":", "line", "=", "lines", "[", "line_no", "]", "line_no", "+=", "1", "if", "line", "!=", "'cmd LC_RPATH'", ":", "continue", "cmdsize", ",", "path", "=", "lines", "[", "line_no", ":", "line_no", "+", "2", "]", "assert", "cmdsize", ".", "startswith", "(", "'cmdsize '", ")", "paths", ".", "append", "(", "RPATH_RE", ".", "match", "(", "path", ")", ".", "groups", "(", ")", "[", "0", "]", ")", "line_no", "+=", "2", "return", "tuple", "(", "paths", ")" ]

[ "Return", "a", "tuple", "of", "rpaths", "from", "the", "library", "filename" ]

[ "def", "dir2zip", "(", "in_dir", ",", "zip_fname", ")", ":", "z", "=", "zipfile", ".", "ZipFile", "(", "zip_fname", ",", "'w'", ",", "compression", "=", "zipfile", ".", "ZIP_DEFLATED", ")", "for", "root", ",", "dirs", ",", "files", "in", "os", ".", "walk", "(", "in_dir", ")", ":", "for", "file", "in", "files", ":", "in_fname", "=", "pjoin", "(", "root", ",", "file", ")", "in_stat", "=", "os", ".", "stat", "(", "in_fname", ")", "# Preserve file permissions, but allow copy", "info", "=", "zipfile", ".", "ZipInfo", "(", "in_fname", ")", "info", ".", "filename", "=", "relpath", "(", "in_fname", ",", "in_dir", ")", "if", "os", ".", "path", ".", "sep", "==", "'\\\\'", ":", "# Make the path unix friendly on windows.", "# PyPI won't accept wheels with windows path separators", "info", ".", "filename", "=", "relpath", "(", "in_fname", ",", "in_dir", ")", ".", "replace", "(", "'\\\\'", ",", "'/'", ")", "# Set time from modification time", "info", ".", "date_time", "=", "time", ".", "localtime", "(", "in_stat", ".", "st_mtime", ")", "# See https://stackoverflow.com/questions/434641/how-do-i-set-permissions-attributes-on-a-file-in-a-zip-file-using-pythons-zip/48435482#48435482", "# Also set regular file permissions", "perms", "=", "stat", ".", "S_IMODE", "(", "in_stat", ".", "st_mode", ")", "|", "stat", ".", "S_IFREG", "info", ".", "external_attr", "=", "perms", "<<", "16", "with", "open_readable", "(", "in_fname", ",", "'rb'", ")", "as", "fobj", ":", "contents", "=", "fobj", ".", "read", "(", ")", "z", ".", "writestr", "(", "info", ",", "contents", ",", "zipfile", ".", "ZIP_DEFLATED", ")", "z", ".", "close", "(", ")" ]

[ "Make", "a", "zip", "file", "zip_fname", "with", "contents", "of", "directory", "in_dir" ]

[ "def", "find_package_dirs", "(", "root_path", ")", ":", "package_sdirs", "=", "set", "(", ")", "for", "entry", "in", "os", ".", "listdir", "(", "root_path", ")", ":", "fname", "=", "entry", "if", "root_path", "==", "'.'", "else", "pjoin", "(", "root_path", ",", "entry", ")", "if", "isdir", "(", "fname", ")", "and", "exists", "(", "pjoin", "(", "fname", ",", "'__init__.py'", ")", ")", ":", "package_sdirs", ".", "add", "(", "fname", ")", "return", "package_sdirs" ]

[ "Find", "python", "package", "directories", "in", "directory", "root_path" ]

[ "def", "cmp_contents", "(", "filename1", ",", "filename2", ")", ":", "with", "open_readable", "(", "filename1", ",", "'rb'", ")", "as", "fobj", ":", "contents1", "=", "fobj", ".", "read", "(", ")", "with", "open_readable", "(", "filename2", ",", "'rb'", ")", "as", "fobj", ":", "contents2", "=", "fobj", ".", "read", "(", ")", "return", "contents1", "==", "contents2" ]

[ "Returns", "True", "if", "contents", "of", "the", "files", "are", "the", "same" ]

[ "def", "get_archs", "(", "libname", ")", ":", "if", "not", "exists", "(", "libname", ")", ":", "raise", "RuntimeError", "(", "libname", "+", "\" is not a file\"", ")", "try", ":", "stdout", "=", "back_tick", "(", "[", "'lipo'", ",", "'-info'", ",", "libname", "]", ")", "except", "RuntimeError", ":", "return", "frozenset", "(", ")", "lines", "=", "[", "line", ".", "strip", "(", ")", "for", "line", "in", "stdout", ".", "split", "(", "'\\n'", ")", "if", "line", ".", "strip", "(", ")", "]", "# For some reason, output from lipo -info on .a file generates this line", "if", "lines", "[", "0", "]", "==", "\"input file {0} is not a fat file\"", ".", "format", "(", "libname", ")", ":", "line", "=", "lines", "[", "1", "]", "else", ":", "assert", "len", "(", "lines", ")", "==", "1", "line", "=", "lines", "[", "0", "]", "for", "reggie", "in", "(", "'Non-fat file: {0} is architecture: (.*)'", ".", "format", "(", "libname", ")", ",", "'Architectures in the fat file: {0} are: (.*)'", ".", "format", "(", "libname", ")", ")", ":", "reggie", "=", "re", ".", "compile", "(", "reggie", ")", "match", "=", "reggie", ".", "match", "(", "line", ")", "if", "not", "match", "is", "None", ":", "return", "frozenset", "(", "match", ".", "groups", "(", ")", "[", "0", "]", ".", "split", "(", "' '", ")", ")", "raise", "ValueError", "(", "\"Unexpected output: '{0}' for {1}\"", ".", "format", "(", "stdout", ",", "libname", ")", ")" ]

[ "Return", "architecture", "types", "from", "library", "libname" ]

[ "def", "validate_signature", "(", "filename", ")", ":", "out", ",", "err", "=", "back_tick", "(", "[", "'codesign'", ",", "'--verify'", ",", "filename", "]", ",", "ret_err", "=", "True", ",", "as_str", "=", "True", ",", "raise_err", "=", "False", ")", "if", "not", "err", ":", "return", "# The existing signature is valid", "if", "'code object is not signed at all'", "in", "err", ":", "return", "# File has no signature, and adding a new one isn't necessary", "# This file's signature is invalid and needs to be replaced", "replace_signature", "(", "filename", ",", "'-'", ")" ]

[ "Remove", "invalid", "signatures", "from", "a", "binary", "file" ]

[ "def", "fuse_trees", "(", "to_tree", ",", "from_tree", ",", "lib_exts", "=", "(", "'.so'", ",", "'.dylib'", ",", "'.a'", ")", ")", ":", "for", "from_dirpath", ",", "dirnames", ",", "filenames", "in", "os", ".", "walk", "(", "from_tree", ")", ":", "to_dirpath", "=", "pjoin", "(", "to_tree", ",", "relpath", "(", "from_dirpath", ",", "from_tree", ")", ")", "# Copy any missing directories in to_path", "for", "dirname", "in", "tuple", "(", "dirnames", ")", ":", "to_path", "=", "pjoin", "(", "to_dirpath", ",", "dirname", ")", "if", "not", "exists", "(", "to_path", ")", ":", "from_path", "=", "pjoin", "(", "from_dirpath", ",", "dirname", ")", "shutil", ".", "copytree", "(", "from_path", ",", "to_path", ")", "# If copying, don't further analyze this directory", "dirnames", ".", "remove", "(", "dirname", ")", "for", "fname", "in", "filenames", ":", "root", ",", "ext", "=", "splitext", "(", "fname", ")", "from_path", "=", "pjoin", "(", "from_dirpath", ",", "fname", ")", "to_path", "=", "pjoin", "(", "to_dirpath", ",", "fname", ")", "if", "not", "exists", "(", "to_path", ")", ":", "_copyfile", "(", "from_path", ",", "to_path", ")", "elif", "cmp_contents", "(", "from_path", ",", "to_path", ")", ":", "pass", "elif", "ext", "in", "lib_exts", ":", "# existing lib that needs fuse", "lipo_fuse", "(", "from_path", ",", "to_path", ",", "to_path", ")", "else", ":", "# existing not-lib file not identical to source", "_copyfile", "(", "from_path", ",", "to_path", ")" ]

[ "Fuse", "path", "from_tree", "into", "path", "to_tree" ]

[ "def", "fuse_wheels", "(", "to_wheel", ",", "from_wheel", ",", "out_wheel", ")", ":", "to_wheel", ",", "from_wheel", ",", "out_wheel", "=", "[", "abspath", "(", "w", ")", "for", "w", "in", "(", "to_wheel", ",", "from_wheel", ",", "out_wheel", ")", "]", "with", "InTemporaryDirectory", "(", ")", ":", "zip2dir", "(", "to_wheel", ",", "'to_wheel'", ")", "zip2dir", "(", "from_wheel", ",", "'from_wheel'", ")", "fuse_trees", "(", "'to_wheel'", ",", "'from_wheel'", ")", "rewrite_record", "(", "'to_wheel'", ")", "dir2zip", "(", "'to_wheel'", ",", "out_wheel", ")" ]

[ "Fuse", "from_wheel", "into", "to_wheel", "write", "to", "out_wheel" ]

[ "def", "delocate_tree_libs", "(", "lib_dict", ",", "lib_path", ",", "root_path", ")", ":", "copied_libs", "=", "{", "}", "delocated_libs", "=", "set", "(", ")", "copied_basenames", "=", "set", "(", ")", "rp_root_path", "=", "realpath", "(", "root_path", ")", "rp_lib_path", "=", "realpath", "(", "lib_path", ")", "# Test for errors first to avoid getting half-way through changing the tree", "for", "required", ",", "requirings", "in", "lib_dict", ".", "items", "(", ")", ":", "if", "required", ".", "startswith", "(", "'@'", ")", ":", "# assume @rpath etc are correct", "# But warn, because likely they are not", "warnings", ".", "warn", "(", "'Not processing required path {0} because it '", "'begins with @'", ".", "format", "(", "required", ")", ")", "continue", "r_ed_base", "=", "basename", "(", "required", ")", "if", "relpath", "(", "required", ",", "rp_root_path", ")", ".", "startswith", "(", "'..'", ")", ":", "# Not local, plan to copy", "if", "r_ed_base", "in", "copied_basenames", ":", "raise", "DelocationError", "(", "'Already planning to copy library with '", "'same basename as: '", "+", "r_ed_base", ")", "if", "not", "exists", "(", "required", ")", ":", "raise", "DelocationError", "(", "'library \"{0}\" does not exist'", ".", "format", "(", "required", ")", ")", "copied_libs", "[", "required", "]", "=", "requirings", "copied_basenames", ".", "add", "(", "r_ed_base", ")", "else", ":", "# Is local, plan to set relative loader_path", "delocated_libs", ".", "add", "(", "required", ")", "# Modify in place now that we've checked for errors", "for", "required", "in", "copied_libs", ":", "shutil", ".", "copy", "(", "required", ",", "lib_path", ")", "# Set rpath and install names for this copied library", "for", "requiring", ",", "orig_install_name", "in", "lib_dict", "[", "required", "]", ".", "items", "(", ")", ":", "req_rel", "=", "relpath", "(", "rp_lib_path", ",", "dirname", "(", "requiring", ")", ")", "set_install_name", "(", "requiring", ",", "orig_install_name", ",", "'@loader_path/{0}/{1}'", ".", "format", "(", "req_rel", ",", "basename", "(", "required", ")", ")", ")", "for", "required", "in", "delocated_libs", ":", "# Set relative path for local library", "for", "requiring", ",", "orig_install_name", "in", "lib_dict", "[", "required", "]", ".", "items", "(", ")", ":", "req_rel", "=", "relpath", "(", "required", ",", "dirname", "(", "requiring", ")", ")", "set_install_name", "(", "requiring", ",", "orig_install_name", ",", "'@loader_path/'", "+", "req_rel", ")", "return", "copied_libs" ]

[ "Move", "needed", "libraries", "in", "lib_dict", "into", "lib_path" ]

[ "def", "copy_recurse", "(", "lib_path", ",", "copy_filt_func", "=", "None", ",", "copied_libs", "=", "None", ")", ":", "if", "copied_libs", "is", "None", ":", "copied_libs", "=", "{", "}", "else", ":", "copied_libs", "=", "dict", "(", "copied_libs", ")", "done", "=", "False", "while", "not", "done", ":", "in_len", "=", "len", "(", "copied_libs", ")", "_copy_required", "(", "lib_path", ",", "copy_filt_func", ",", "copied_libs", ")", "done", "=", "len", "(", "copied_libs", ")", "==", "in_len", "return", "copied_libs" ]

[ "Analyze", "lib_path", "for", "library", "dependencies", "and", "copy", "libraries" ]

[ "def", "_copy_required", "(", "lib_path", ",", "copy_filt_func", ",", "copied_libs", ")", ":", "# Paths will be prepended with `lib_path`", "lib_dict", "=", "tree_libs", "(", "lib_path", ")", "# Map library paths after copy ('copied') to path before copy ('orig')", "rp_lp", "=", "realpath", "(", "lib_path", ")", "copied2orig", "=", "dict", "(", "(", "pjoin", "(", "rp_lp", ",", "basename", "(", "c", ")", ")", ",", "c", ")", "for", "c", "in", "copied_libs", ")", "for", "required", ",", "requirings", "in", "lib_dict", ".", "items", "(", ")", ":", "if", "not", "copy_filt_func", "is", "None", "and", "not", "copy_filt_func", "(", "required", ")", ":", "continue", "if", "required", ".", "startswith", "(", "'@'", ")", ":", "# May have been processed by us, or have some rpath, loader_path of", "# its own. Either way, leave alone", "continue", "# Requiring names may well be the copies in lib_path. Replace the copy", "# names with the original names for entry into `copied_libs`", "procd_requirings", "=", "{", "}", "# Set requiring lib install names to point to local copy", "for", "requiring", ",", "orig_install_name", "in", "requirings", ".", "items", "(", ")", ":", "set_install_name", "(", "requiring", ",", "orig_install_name", ",", "'@loader_path/'", "+", "basename", "(", "required", ")", ")", "# Make processed version of ``dependings_dict``", "mapped_requiring", "=", "copied2orig", ".", "get", "(", "requiring", ",", "requiring", ")", "procd_requirings", "[", "mapped_requiring", "]", "=", "orig_install_name", "if", "required", "in", "copied_libs", ":", "# Have copied this already, add any new requirings", "copied_libs", "[", "required", "]", ".", "update", "(", "procd_requirings", ")", "continue", "# Haven't see this one before, add entry to copied_libs", "out_path", "=", "pjoin", "(", "lib_path", ",", "basename", "(", "required", ")", ")", "if", "exists", "(", "out_path", ")", ":", "raise", "DelocationError", "(", "out_path", "+", "' already exists'", ")", "shutil", ".", "copy", "(", "required", ",", "lib_path", ")", "copied2orig", "[", "out_path", "]", "=", "required", "copied_libs", "[", "required", "]", "=", "procd_requirings" ]

[ "Copy", "libraries", "required", "for", "files", "in", "lib_path", "to", "lib_path" ]

[ "def", "delocate_path", "(", "tree_path", ",", "lib_path", ",", "lib_filt_func", "=", "None", ",", "copy_filt_func", "=", "filter_system_libs", ")", ":", "if", "lib_filt_func", "==", "\"dylibs-only\"", ":", "lib_filt_func", "=", "_dylibs_only", "if", "not", "exists", "(", "lib_path", ")", ":", "os", ".", "makedirs", "(", "lib_path", ")", "lib_dict", "=", "tree_libs", "(", "tree_path", ",", "lib_filt_func", ")", "if", "not", "copy_filt_func", "is", "None", ":", "lib_dict", "=", "dict", "(", "(", "key", ",", "value", ")", "for", "key", ",", "value", "in", "lib_dict", ".", "items", "(", ")", "if", "copy_filt_func", "(", "key", ")", ")", "copied", "=", "delocate_tree_libs", "(", "lib_dict", ",", "lib_path", ",", "tree_path", ")", "return", "copy_recurse", "(", "lib_path", ",", "copy_filt_func", ",", "copied", ")" ]

[ "Copy", "required", "libraries", "for", "files", "in", "tree_path", "into", "lib_path" ]

[ "def", "_merge_lib_dict", "(", "d1", ",", "d2", ")", ":", "for", "required", ",", "requirings", "in", "d2", ".", "items", "(", ")", ":", "if", "required", "in", "d1", ":", "d1", "[", "required", "]", ".", "update", "(", "requirings", ")", "else", ":", "d1", "[", "required", "]", "=", "requirings", "return", "None" ]

[ "Merges", "lib_dict", "d2", "into", "lib_dict", "d1" ]

[ "def", "delocate_wheel", "(", "in_wheel", ",", "out_wheel", "=", "None", ",", "lib_sdir", "=", "'.dylibs'", ",", "lib_filt_func", "=", "None", ",", "copy_filt_func", "=", "filter_system_libs", ",", "require_archs", "=", "None", ",", "check_verbose", "=", "False", ",", ")", ":", "if", "lib_filt_func", "==", "\"dylibs-only\"", ":", "lib_filt_func", "=", "_dylibs_only", "in_wheel", "=", "abspath", "(", "in_wheel", ")", "if", "out_wheel", "is", "None", ":", "out_wheel", "=", "in_wheel", "else", ":", "out_wheel", "=", "abspath", "(", "out_wheel", ")", "in_place", "=", "in_wheel", "==", "out_wheel", "with", "TemporaryDirectory", "(", ")", "as", "tmpdir", ":", "all_copied", "=", "{", "}", "wheel_dir", "=", "realpath", "(", "pjoin", "(", "tmpdir", ",", "'wheel'", ")", ")", "zip2dir", "(", "in_wheel", ",", "wheel_dir", ")", "for", "package_path", "in", "find_package_dirs", "(", "wheel_dir", ")", ":", "lib_path", "=", "pjoin", "(", "package_path", ",", "lib_sdir", ")", "lib_path_exists", "=", "exists", "(", "lib_path", ")", "copied_libs", "=", "delocate_path", "(", "package_path", ",", "lib_path", ",", "lib_filt_func", ",", "copy_filt_func", ")", "if", "copied_libs", "and", "lib_path_exists", ":", "raise", "DelocationError", "(", "'{0} already exists in wheel but need to copy '", "'{1}'", ".", "format", "(", "lib_path", ",", "'; '", ".", "join", "(", "copied_libs", ")", ")", ")", "if", "len", "(", "os", ".", "listdir", "(", "lib_path", ")", ")", "==", "0", ":", "shutil", ".", "rmtree", "(", "lib_path", ")", "# Check architectures", "if", "not", "require_archs", "is", "None", ":", "stop_fast", "=", "not", "check_verbose", "bads", "=", "check_archs", "(", "copied_libs", ",", "require_archs", ",", "stop_fast", ")", "if", "len", "(", "bads", ")", "!=", "0", ":", "if", "check_verbose", ":", "print", "(", "bads_report", "(", "bads", ",", "pjoin", "(", "tmpdir", ",", "'wheel'", ")", ")", ")", "raise", "DelocationError", "(", "\"Some missing architectures in wheel\"", ")", "# Change install ids to be unique within Python space", "install_id_root", "=", "(", "DLC_PREFIX", "+", "relpath", "(", "package_path", ",", "wheel_dir", ")", "+", "'/'", ")", "for", "lib", "in", "copied_libs", ":", "lib_base", "=", "basename", "(", "lib", ")", "copied_path", "=", "pjoin", "(", "lib_path", ",", "lib_base", ")", "set_install_id", "(", "copied_path", ",", "install_id_root", "+", "lib_base", ")", "validate_signature", "(", "copied_path", ")", "_merge_lib_dict", "(", "all_copied", ",", "copied_libs", ")", "if", "len", "(", "all_copied", ")", ":", "rewrite_record", "(", "wheel_dir", ")", "if", "len", "(", "all_copied", ")", "or", "not", "in_place", ":", "dir2zip", "(", "wheel_dir", ",", "out_wheel", ")", "return", "stripped_lib_dict", "(", "all_copied", ",", "wheel_dir", "+", "os", ".", "path", ".", "sep", ")" ]

[ "Update", "wheel", "by", "copying", "required", "libraries", "to", "lib_sdir", "in", "wheel" ]

[ "def", "patch_wheel", "(", "in_wheel", ",", "patch_fname", ",", "out_wheel", "=", "None", ")", ":", "in_wheel", "=", "abspath", "(", "in_wheel", ")", "patch_fname", "=", "abspath", "(", "patch_fname", ")", "if", "out_wheel", "is", "None", ":", "out_wheel", "=", "in_wheel", "else", ":", "out_wheel", "=", "abspath", "(", "out_wheel", ")", "if", "not", "exists", "(", "patch_fname", ")", ":", "raise", "ValueError", "(", "\"patch file {0} does not exist\"", ".", "format", "(", "patch_fname", ")", ")", "with", "InWheel", "(", "in_wheel", ",", "out_wheel", ")", ":", "with", "open", "(", "patch_fname", ",", "'rb'", ")", "as", "fobj", ":", "patch_proc", "=", "Popen", "(", "[", "'patch'", ",", "'-p1'", "]", ",", "stdin", "=", "fobj", ",", "stdout", "=", "PIPE", ",", "stderr", "=", "PIPE", ")", "stdout", ",", "stderr", "=", "patch_proc", ".", "communicate", "(", ")", "if", "patch_proc", ".", "returncode", "!=", "0", ":", "raise", "RuntimeError", "(", "\"Patch failed with stdout:\\n\"", "+", "stdout", ".", "decode", "(", "'latin1'", ")", ")" ]

[ "Apply", "-", "p1", "style", "patch", "in", "patch_fname", "to", "contents", "of", "in_wheel" ]

[ "def", "check_archs", "(", "copied_libs", ",", "require_archs", "=", "(", ")", ",", "stop_fast", "=", "False", ")", ":", "if", "isinstance", "(", "require_archs", ",", "string_types", ")", ":", "require_archs", "=", "(", "[", "'i386'", ",", "'x86_64'", "]", "if", "require_archs", "==", "'intel'", "else", "[", "require_archs", "]", ")", "require_archs", "=", "frozenset", "(", "require_archs", ")", "bads", "=", "[", "]", "for", "depended_lib", ",", "dep_dict", "in", "copied_libs", ".", "items", "(", ")", ":", "depended_archs", "=", "get_archs", "(", "depended_lib", ")", "for", "depending_lib", ",", "install_name", "in", "dep_dict", ".", "items", "(", ")", ":", "depending_archs", "=", "get_archs", "(", "depending_lib", ")", "all_required", "=", "depending_archs", "|", "require_archs", "all_missing", "=", "all_required", ".", "difference", "(", "depended_archs", ")", "if", "len", "(", "all_missing", ")", "==", "0", ":", "continue", "required_missing", "=", "require_archs", ".", "difference", "(", "depended_archs", ")", "if", "len", "(", "required_missing", ")", ":", "bads", ".", "append", "(", "(", "depending_lib", ",", "required_missing", ")", ")", "else", ":", "bads", ".", "append", "(", "(", "depended_lib", ",", "depending_lib", ",", "all_missing", ")", ")", "if", "stop_fast", ":", "return", "set", "(", "bads", ")", "return", "set", "(", "bads", ")" ]

[ "Check", "compatibility", "of", "archs", "in", "copied_libs", "dict" ]

[ "def", "bads_report", "(", "bads", ",", "path_prefix", "=", "None", ")", ":", "path_processor", "=", "(", "(", "lambda", "x", ":", "x", ")", "if", "path_prefix", "is", "None", "else", "get_rp_stripper", "(", "path_prefix", ")", ")", "reports", "=", "[", "]", "for", "result", "in", "bads", ":", "if", "len", "(", "result", ")", "==", "3", ":", "depended_lib", ",", "depending_lib", ",", "missing_archs", "=", "result", "reports", ".", "append", "(", "\"{0} needs {1} {2} missing from {3}\"", ".", "format", "(", "path_processor", "(", "depending_lib", ")", ",", "'archs'", "if", "len", "(", "missing_archs", ")", ">", "1", "else", "'arch'", ",", "', '", ".", "join", "(", "sorted", "(", "missing_archs", ")", ")", ",", "path_processor", "(", "depended_lib", ")", ")", ")", "elif", "len", "(", "result", ")", "==", "2", ":", "depending_lib", ",", "missing_archs", "=", "result", "reports", ".", "append", "(", "\"Required {0} {1} missing from {2}\"", ".", "format", "(", "'archs'", "if", "len", "(", "missing_archs", ")", ">", "1", "else", "'arch'", ",", "', '", ".", "join", "(", "sorted", "(", "missing_archs", ")", ")", ",", "path_processor", "(", "depending_lib", ")", ")", ")", "else", ":", "raise", "ValueError", "(", "'Report tuple should be length 2 or 3'", ")", "return", "'\\n'", ".", "join", "(", "sorted", "(", "reports", ")", ")" ]

[ "Return", "a", "nice", "report", "of", "bad", "architectures", "in", "bads" ]

[ "def", "tree_libs", "(", "start_path", ",", "filt_func", "=", "None", ")", ":", "lib_dict", "=", "{", "}", "for", "dirpath", ",", "dirnames", ",", "basenames", "in", "os", ".", "walk", "(", "start_path", ")", ":", "for", "base", "in", "basenames", ":", "depending_libpath", "=", "realpath", "(", "pjoin", "(", "dirpath", ",", "base", ")", ")", "if", "not", "filt_func", "is", "None", "and", "not", "filt_func", "(", "depending_libpath", ")", ":", "continue", "rpaths", "=", "get_rpaths", "(", "depending_libpath", ")", "for", "install_name", "in", "get_install_names", "(", "depending_libpath", ")", ":", "lib_path", "=", "(", "install_name", "if", "install_name", ".", "startswith", "(", "'@'", ")", "else", "realpath", "(", "install_name", ")", ")", "lib_path", "=", "resolve_rpath", "(", "lib_path", ",", "rpaths", ")", "if", "lib_path", "in", "lib_dict", ":", "lib_dict", "[", "lib_path", "]", "[", "depending_libpath", "]", "=", "install_name", "else", ":", "lib_dict", "[", "lib_path", "]", "=", "{", "depending_libpath", ":", "install_name", "}", "return", "lib_dict" ]

[ "Return", "analysis", "of", "library", "dependencies", "within", "start_path" ]

[ "def", "get_prefix_stripper", "(", "strip_prefix", ")", ":", "n", "=", "len", "(", "strip_prefix", ")", "def", "stripper", "(", "path", ")", ":", "return", "path", "if", "not", "path", ".", "startswith", "(", "strip_prefix", ")", "else", "path", "[", "n", ":", "]", "return", "stripper" ]

[ "Return", "function", "to", "strip", "strip_prefix", "prefix", "from", "string", "if", "present" ]

[ "def", "stripped_lib_dict", "(", "lib_dict", ",", "strip_prefix", ")", ":", "relative_dict", "=", "{", "}", "stripper", "=", "get_prefix_stripper", "(", "strip_prefix", ")", "for", "lib_path", ",", "dependings_dict", "in", "lib_dict", ".", "items", "(", ")", ":", "ding_dict", "=", "{", "}", "for", "depending_libpath", ",", "install_name", "in", "dependings_dict", ".", "items", "(", ")", ":", "ding_dict", "[", "stripper", "(", "depending_libpath", ")", "]", "=", "install_name", "relative_dict", "[", "stripper", "(", "lib_path", ")", "]", "=", "ding_dict", "return", "relative_dict" ]

[ "Return", "lib_dict", "with", "strip_prefix", "removed", "from", "start", "of", "paths" ]

[ "def", "wheel_libs", "(", "wheel_fname", ",", "filt_func", "=", "None", ")", ":", "with", "TemporaryDirectory", "(", ")", "as", "tmpdir", ":", "zip2dir", "(", "wheel_fname", ",", "tmpdir", ")", "lib_dict", "=", "tree_libs", "(", "tmpdir", ",", "filt_func", ")", "return", "stripped_lib_dict", "(", "lib_dict", ",", "realpath", "(", "tmpdir", ")", "+", "os", ".", "path", ".", "sep", ")" ]

[ "Return", "analysis", "of", "library", "dependencies", "with", "a", "Python", "wheel" ]

[ "def", "rewrite_record", "(", "bdist_dir", ")", ":", "info_dirs", "=", "glob", ".", "glob", "(", "pjoin", "(", "bdist_dir", ",", "'*.dist-info'", ")", ")", "if", "len", "(", "info_dirs", ")", "!=", "1", ":", "raise", "WheelToolsError", "(", "\"Should be exactly one `*.dist_info` directory\"", ")", "record_path", "=", "pjoin", "(", "info_dirs", "[", "0", "]", ",", "'RECORD'", ")", "record_relpath", "=", "relpath", "(", "record_path", ",", "bdist_dir", ")", "# Unsign wheel - because we're invalidating the record hash", "sig_path", "=", "pjoin", "(", "info_dirs", "[", "0", "]", ",", "'RECORD.jws'", ")", "if", "exists", "(", "sig_path", ")", ":", "os", ".", "unlink", "(", "sig_path", ")", "def", "walk", "(", ")", ":", "for", "dir", ",", "dirs", ",", "files", "in", "os", ".", "walk", "(", "bdist_dir", ")", ":", "for", "f", "in", "files", ":", "yield", "pjoin", "(", "dir", ",", "f", ")", "def", "skip", "(", "path", ")", ":", "\"\"\"Wheel hashes every possible file.\"\"\"", "return", "(", "path", "==", "record_relpath", ")", "with", "_open_for_csv", "(", "record_path", ",", "'w+'", ")", "as", "record_file", ":", "writer", "=", "csv", ".", "writer", "(", "record_file", ")", "for", "path", "in", "walk", "(", ")", ":", "relative_path", "=", "relpath", "(", "path", ",", "bdist_dir", ")", "if", "skip", "(", "relative_path", ")", ":", "hash", "=", "''", "size", "=", "''", "else", ":", "with", "open", "(", "path", ",", "'rb'", ")", "as", "f", ":", "data", "=", "f", ".", "read", "(", ")", "digest", "=", "hashlib", ".", "sha256", "(", "data", ")", ".", "digest", "(", ")", "hash", "=", "'sha256='", "+", "native", "(", "urlsafe_b64encode", "(", "digest", ")", ")", "size", "=", "len", "(", "data", ")", "path_for_record", "=", "relpath", "(", "path", ",", "bdist_dir", ")", ".", "replace", "(", "psep", ",", "'/'", ")", "writer", ".", "writerow", "(", "(", "path_for_record", ",", "hash", ",", "size", ")", ")" ]

[ "Rewrite", "RECORD", "file", "with", "hashes", "for", "all", "files", "in", "wheel_sdir" ]

[ "def", "add_platforms", "(", "in_wheel", ",", "platforms", ",", "out_path", "=", "None", ",", "clobber", "=", "False", ")", ":", "in_wheel", "=", "abspath", "(", "in_wheel", ")", "out_path", "=", "dirname", "(", "in_wheel", ")", "if", "out_path", "is", "None", "else", "abspath", "(", "out_path", ")", "wf", "=", "WheelFile", "(", "in_wheel", ")", "info_fname", "=", "_get_wheelinfo_name", "(", "wf", ")", "# Check what tags we have", "in_fname_tags", "=", "wf", ".", "parsed_filename", ".", "groupdict", "(", ")", "[", "'plat'", "]", ".", "split", "(", "'.'", ")", "extra_fname_tags", "=", "[", "tag", "for", "tag", "in", "platforms", "if", "tag", "not", "in", "in_fname_tags", "]", "in_wheel_base", ",", "ext", "=", "splitext", "(", "basename", "(", "in_wheel", ")", ")", "out_wheel_base", "=", "'.'", ".", "join", "(", "[", "in_wheel_base", "]", "+", "list", "(", "extra_fname_tags", ")", ")", "out_wheel", "=", "pjoin", "(", "out_path", ",", "out_wheel_base", "+", "ext", ")", "if", "exists", "(", "out_wheel", ")", "and", "not", "clobber", ":", "raise", "WheelToolsError", "(", "'Not overwriting {0}; set clobber=True '", "'to overwrite'", ".", "format", "(", "out_wheel", ")", ")", "with", "InWheelCtx", "(", "in_wheel", ")", "as", "ctx", ":", "info", "=", "read_pkg_info", "(", "info_fname", ")", "if", "info", "[", "'Root-Is-Purelib'", "]", "==", "'true'", ":", "raise", "WheelToolsError", "(", "'Cannot add platforms to pure wheel'", ")", "in_info_tags", "=", "[", "tag", "for", "name", ",", "tag", "in", "info", ".", "items", "(", ")", "if", "name", "==", "'Tag'", "]", "# Python version, C-API version combinations", "pyc_apis", "=", "[", "'-'", ".", "join", "(", "tag", ".", "split", "(", "'-'", ")", "[", ":", "2", "]", ")", "for", "tag", "in", "in_info_tags", "]", "# unique Python version, C-API version combinations", "pyc_apis", "=", "unique_by_index", "(", "pyc_apis", ")", "# Add new platform tags for each Python version, C-API combination", "required_tags", "=", "[", "'-'", ".", "join", "(", "tup", ")", "for", "tup", "in", "product", "(", "pyc_apis", ",", "platforms", ")", "]", "needs_write", "=", "False", "for", "req_tag", "in", "required_tags", ":", "if", "req_tag", "in", "in_info_tags", ":", "continue", "needs_write", "=", "True", "info", ".", "add_header", "(", "'Tag'", ",", "req_tag", ")", "if", "needs_write", ":", "write_pkg_info", "(", "info_fname", ",", "info", ")", "# Tell context manager to write wheel on exit by setting filename", "ctx", ".", "out_wheel", "=", "out_wheel", "return", "ctx", ".", "out_wheel" ]

[ "Add", "platform", "tags", "platforms", "to", "in_wheel", "filename", "and", "WHEEL", "tags" ]

[ "def", "temporal_betweenness_centrality", "(", "tnet", "=", "None", ",", "paths", "=", "None", ",", "calc", "=", "'time'", ")", ":", "if", "tnet", "is", "not", "None", "and", "paths", "is", "not", "None", ":", "raise", "ValueError", "(", "'Only network or path input allowed.'", ")", "if", "tnet", "is", "None", "and", "paths", "is", "None", ":", "raise", "ValueError", "(", "'No input.'", ")", "# if shortest paths are not calculated, calculate them", "if", "tnet", "is", "not", "None", ":", "paths", "=", "shortest_temporal_path", "(", "tnet", ")", "bet", "=", "np", ".", "zeros", "(", "[", "paths", "[", "[", "'from'", ",", "'to'", "]", "]", ".", "max", "(", ")", ".", "max", "(", ")", "+", "1", ",", "paths", "[", "'t_start'", "]", ".", "max", "(", ")", "+", "1", "]", ")", "for", "row", "in", "paths", ".", "iterrows", "(", ")", ":", "if", "(", "np", ".", "isnan", "(", "row", "[", "1", "]", "[", "'path includes'", "]", ")", ")", ".", "all", "(", ")", ":", "pass", "else", ":", "nodes_in_path", "=", "np", ".", "unique", "(", "np", ".", "concatenate", "(", "row", "[", "1", "]", "[", "'path includes'", "]", ")", ")", ".", "astype", "(", "int", ")", ".", "tolist", "(", ")", "nodes_in_path", ".", "remove", "(", "row", "[", "1", "]", "[", "'from'", "]", ")", "nodes_in_path", ".", "remove", "(", "row", "[", "1", "]", "[", "'to'", "]", ")", "if", "len", "(", "nodes_in_path", ")", ">", "0", ":", "bet", "[", "nodes_in_path", ",", "row", "[", "1", "]", "[", "'t_start'", "]", "]", "+=", "1", "# Normalise bet", "bet", "=", "(", "1", "/", "(", "(", "bet", ".", "shape", "[", "0", "]", "-", "1", ")", "*", "(", "bet", ".", "shape", "[", "0", "]", "-", "2", ")", ")", ")", "*", "bet", "if", "calc", "==", "'global'", ":", "bet", "=", "np", ".", "mean", "(", "bet", ",", "axis", "=", "1", ")", "return", "bet" ]

[ "Returns", "temporal", "betweenness", "centrality", "per", "node", "." ]

[ "def", "allegiance", "(", "community", ")", ":", "N", "=", "community", ".", "shape", "[", "0", "]", "C", "=", "community", ".", "shape", "[", "1", "]", "T", "=", "P", "=", "np", ".", "zeros", "(", "[", "N", ",", "N", "]", ")", "for", "t", "in", "range", "(", "len", "(", "community", "[", "0", ",", ":", "]", ")", ")", ":", "for", "i", "in", "range", "(", "len", "(", "community", "[", ":", ",", "0", "]", ")", ")", ":", "for", "j", "in", "range", "(", "len", "(", "community", "[", ":", ",", "0", "]", ")", ")", ":", "if", "i", "==", "j", ":", "continue", "# T_ij indicates the number of times that i and j are assigned to the same community across time", "if", "community", "[", "i", "]", "[", "t", "]", "==", "community", "[", "j", "]", "[", "t", "]", ":", "T", "[", "i", ",", "j", "]", "+=", "1", "# module allegiance matrix, probability that ij were assigned to the same community", "P", "=", "(", "1", "/", "C", ")", "*", "T", "return", "P" ]

[ "Computes", "the", "allegiance", "matrix", "with", "values", "representing", "the", "probability", "that", "nodes", "i", "and", "j", "were", "assigned", "to", "the", "same", "community", "by", "time", "-", "varying", "clustering", "methods", "." ]

[ "def", "rand_poisson", "(", "nnodes", ",", "ncontacts", ",", "lam", "=", "1", ",", "nettype", "=", "'bu'", ",", "netinfo", "=", "None", ",", "netrep", "=", "'graphlet'", ")", ":", "if", "isinstance", "(", "ncontacts", ",", "list", ")", ":", "if", "len", "(", "ncontacts", ")", "!=", "nnodes", ":", "raise", "ValueError", "(", "'Number of contacts, if a list, should be one per node'", ")", "if", "isinstance", "(", "lam", ",", "list", ")", ":", "if", "len", "(", "lam", ")", "!=", "nnodes", ":", "raise", "ValueError", "(", "'Lambda value of Poisson distribution, if a list, should be one per node'", ")", "if", "isinstance", "(", "lam", ",", "list", ")", "and", "not", "isinstance", "(", "ncontacts", ",", "list", ")", "or", "not", "isinstance", "(", "lam", ",", "list", ")", "and", "isinstance", "(", "ncontacts", ",", "list", ")", ":", "raise", "ValueError", "(", "'When one of lambda or ncontacts is given as a list, the other argument must also be a list.'", ")", "if", "nettype", "==", "'bu'", ":", "edgen", "=", "int", "(", "(", "nnodes", "*", "(", "nnodes", "-", "1", ")", ")", "/", "2", ")", "elif", "nettype", "==", "'bd'", ":", "edgen", "=", "int", "(", "nnodes", "*", "nnodes", ")", "if", "not", "isinstance", "(", "lam", ",", "list", ")", "and", "not", "isinstance", "(", "ncontacts", ",", "list", ")", ":", "icts", "=", "np", ".", "random", ".", "poisson", "(", "lam", ",", "size", "=", "(", "edgen", ",", "ncontacts", ")", ")", "net", "=", "np", ".", "zeros", "(", "[", "edgen", ",", "icts", ".", "sum", "(", "axis", "=", "1", ")", ".", "max", "(", ")", "+", "1", "]", ")", "for", "n", "in", "range", "(", "edgen", ")", ":", "net", "[", "n", ",", "np", ".", "unique", "(", "np", ".", "cumsum", "(", "icts", "[", "n", "]", ")", ")", "]", "=", "1", "else", ":", "icts", "=", "[", "]", "ict_max", "=", "0", "for", "n", "in", "range", "(", "edgen", ")", ":", "icts", ".", "append", "(", "np", ".", "random", ".", "poisson", "(", "lam", "[", "n", "]", ",", "size", "=", "ncontacts", "[", "n", "]", ")", ")", "if", "sum", "(", "icts", "[", "-", "1", "]", ")", ">", "ict_max", ":", "ict_max", "=", "sum", "(", "icts", "[", "-", "1", "]", ")", "net", "=", "np", ".", "zeros", "(", "[", "nnodes", ",", "ict_max", "+", "1", "]", ")", "for", "n", "in", "range", "(", "nnodes", ")", ":", "net", "[", "n", ",", "np", ".", "unique", "(", "np", ".", "cumsum", "(", "icts", "[", "n", "]", ")", ")", "]", "=", "1", "if", "nettype", "==", "'bu'", ":", "nettmp", "=", "np", ".", "zeros", "(", "[", "nnodes", ",", "nnodes", ",", "net", ".", "shape", "[", "-", "1", "]", "]", ")", "ind", "=", "np", ".", "triu_indices", "(", "nnodes", ",", "k", "=", "1", ")", "nettmp", "[", "ind", "[", "0", "]", ",", "ind", "[", "1", "]", ",", ":", "]", "=", "net", "net", "=", "nettmp", "+", "nettmp", ".", "transpose", "(", "[", "1", ",", "0", ",", "2", "]", ")", "elif", "nettype", "==", "'bd'", ":", "net", "=", "net", ".", "reshape", "(", "[", "nnodes", ",", "nnodes", ",", "net", ".", "shape", "[", "-", "1", "]", "]", ",", "order", "=", "'F'", ")", "net", "=", "set_diagonal", "(", "net", ",", "0", ")", "if", "netrep", "==", "'contact'", ":", "if", "not", "netinfo", ":", "netinfo", "=", "{", "}", "netinfo", "[", "'nettype'", "]", "=", "'b'", "+", "nettype", "[", "-", "1", "]", "net", "=", "graphlet2contact", "(", "net", ",", "netinfo", ")", "return", "net" ]

[ "Generate", "a", "random", "network", "where", "intervals", "between", "contacts", "are", "distributed", "by", "a", "poisson", "distribution" ]

[ "def", "temporal_efficiency", "(", "tnet", "=", "None", ",", "paths", "=", "None", ",", "calc", "=", "'global'", ")", ":", "if", "tnet", "is", "not", "None", "and", "paths", "is", "not", "None", ":", "raise", "ValueError", "(", "'Only network or path input allowed.'", ")", "if", "tnet", "is", "None", "and", "paths", "is", "None", ":", "raise", "ValueError", "(", "'No input.'", ")", "# if shortest paths are not calculated, calculate them", "if", "tnet", "is", "not", "None", ":", "paths", "=", "shortest_temporal_path", "(", "tnet", ")", "pathmat", "=", "np", ".", "zeros", "(", "[", "paths", "[", "[", "'from'", ",", "'to'", "]", "]", ".", "max", "(", ")", ".", "max", "(", ")", "+", "1", ",", "paths", "[", "[", "'from'", ",", "'to'", "]", "]", ".", "max", "(", ")", ".", "max", "(", ")", "+", "1", ",", "paths", "[", "[", "'t_start'", "]", "]", ".", "max", "(", ")", ".", "max", "(", ")", "+", "1", "]", ")", "*", "np", ".", "nan", "pathmat", "[", "paths", "[", "'from'", "]", ".", "values", ",", "paths", "[", "'to'", "]", ".", "values", ",", "paths", "[", "'t_start'", "]", ".", "values", "]", "=", "paths", "[", "'temporal-distance'", "]", "# Calculate efficiency which is 1 over the mean path.", "if", "calc", "==", "'global'", ":", "eff", "=", "1", "/", "np", ".", "nanmean", "(", "pathmat", ")", "elif", "calc", "==", "'node'", "or", "calc", "==", "'node_from'", ":", "eff", "=", "1", "/", "np", ".", "nanmean", "(", "np", ".", "nanmean", "(", "pathmat", ",", "axis", "=", "2", ")", ",", "axis", "=", "1", ")", "elif", "calc", "==", "'node_to'", ":", "eff", "=", "1", "/", "np", ".", "nanmean", "(", "np", ".", "nanmean", "(", "pathmat", ",", "axis", "=", "2", ")", ",", "axis", "=", "0", ")", "return", "eff" ]

[ "r", "Returns", "temporal", "efficiency", "estimate", ".", "BU", "networks", "only", "." ]

[ "def", "network_from_array", "(", "self", ",", "array", ")", ":", "if", "len", "(", "array", ".", "shape", ")", "==", "2", ":", "array", "=", "np", ".", "array", "(", "array", ",", "ndmin", "=", "3", ")", ".", "transpose", "(", "[", "1", ",", "2", ",", "0", "]", ")", "teneto", ".", "utils", ".", "check_TemporalNetwork_input", "(", "array", ",", "'array'", ")", "uvals", "=", "np", ".", "unique", "(", "array", ")", "if", "len", "(", "uvals", ")", "==", "2", "and", "1", "in", "uvals", "and", "0", "in", "uvals", ":", "i", ",", "j", ",", "t", "=", "np", ".", "where", "(", "array", "==", "1", ")", "self", ".", "network", "=", "pd", ".", "DataFrame", "(", "data", "=", "{", "'i'", ":", "i", ",", "'j'", ":", "j", ",", "'t'", ":", "t", "}", ")", "else", ":", "i", ",", "j", ",", "t", "=", "np", ".", "where", "(", "array", "!=", "0", ")", "w", "=", "array", "[", "array", "!=", "0", "]", "self", ".", "network", "=", "pd", ".", "DataFrame", "(", "data", "=", "{", "'i'", ":", "i", ",", "'j'", ":", "j", ",", "'t'", ":", "t", ",", "'weight'", ":", "w", "}", ")", "self", ".", "N", "=", "int", "(", "array", ".", "shape", "[", "0", "]", ")", "self", ".", "T", "=", "int", "(", "array", ".", "shape", "[", "-", "1", "]", ")", "self", ".", "_update_network", "(", ")" ]

[ "impo", "Defines", "a", "network", "from", "an", "array", "." ]

[ "def", "_drop_duplicate_ij", "(", "self", ")", ":", "self", ".", "network", "[", "'ij'", "]", "=", "list", "(", "map", "(", "lambda", "x", ":", "tuple", "(", "sorted", "(", "x", ")", ")", ",", "list", "(", "zip", "(", "*", "[", "self", ".", "network", "[", "'i'", "]", ".", "values", ",", "self", ".", "network", "[", "'j'", "]", ".", "values", "]", ")", ")", ")", ")", "self", ".", "network", ".", "drop_duplicates", "(", "[", "'ij'", ",", "'t'", "]", ",", "inplace", "=", "True", ")", "self", ".", "network", ".", "reset_index", "(", "inplace", "=", "True", ",", "drop", "=", "True", ")", "self", ".", "network", ".", "drop", "(", "'ij'", ",", "inplace", "=", "True", ",", "axis", "=", "1", ")" ]

[ "Drops", "duplicate", "entries", "from", "the", "network", "dataframe", "." ]

[ "def", "_drop_diagonal", "(", "self", ")", ":", "self", ".", "network", "=", "self", ".", "network", ".", "where", "(", "self", ".", "network", "[", "'i'", "]", "!=", "self", ".", "network", "[", "'j'", "]", ")", ".", "dropna", "(", ")", "self", ".", "network", ".", "reset_index", "(", "inplace", "=", "True", ",", "drop", "=", "True", ")" ]

[ "Drops", "self", "-", "contacts", "from", "the", "network", "dataframe", "." ]

[ "def", "add_edge", "(", "self", ",", "edgelist", ")", ":", "if", "not", "isinstance", "(", "edgelist", "[", "0", "]", ",", "list", ")", ":", "edgelist", "=", "[", "edgelist", "]", "teneto", ".", "utils", ".", "check_TemporalNetwork_input", "(", "edgelist", ",", "'edgelist'", ")", "if", "len", "(", "edgelist", "[", "0", "]", ")", "==", "4", ":", "colnames", "=", "[", "'i'", ",", "'j'", ",", "'t'", ",", "'weight'", "]", "elif", "len", "(", "edgelist", "[", "0", "]", ")", "==", "3", ":", "colnames", "=", "[", "'i'", ",", "'j'", ",", "'t'", "]", "if", "self", ".", "hdf5", ":", "with", "pd", ".", "HDFStore", "(", "self", ".", "network", ")", "as", "hdf", ":", "rows", "=", "hdf", ".", "get_storer", "(", "'network'", ")", ".", "nrows", "hdf", ".", "append", "(", "'network'", ",", "pd", ".", "DataFrame", "(", "edgelist", ",", "columns", "=", "colnames", ",", "index", "=", "np", ".", "arange", "(", "rows", ",", "rows", "+", "len", "(", "edgelist", ")", ")", ")", ",", "format", "=", "'table'", ",", "data_columns", "=", "True", ")", "edgelist", "=", "np", ".", "array", "(", "edgelist", ")", "if", "np", ".", "max", "(", "edgelist", "[", ":", ",", ":", "2", "]", ")", ">", "self", ".", "netshape", "[", "0", "]", ":", "self", ".", "netshape", "[", "0", "]", "=", "np", ".", "max", "(", "edgelist", "[", ":", ",", ":", "2", "]", ")", "if", "np", ".", "max", "(", "edgelist", "[", ":", ",", "2", "]", ")", ">", "self", ".", "netshape", "[", "1", "]", ":", "self", ".", "netshape", "[", "1", "]", "=", "np", ".", "max", "(", "edgelist", "[", ":", ",", "2", "]", ")", "else", ":", "newedges", "=", "pd", ".", "DataFrame", "(", "edgelist", ",", "columns", "=", "colnames", ")", "self", ".", "network", "=", "pd", ".", "concat", "(", "[", "self", ".", "network", ",", "newedges", "]", ",", "ignore_index", "=", "True", ",", "sort", "=", "True", ")", "self", ".", "_update_network", "(", ")" ]

[ "Adds", "an", "edge", "from", "network", "." ]

[ "def", "drop_edge", "(", "self", ",", "edgelist", ")", ":", "if", "not", "isinstance", "(", "edgelist", "[", "0", "]", ",", "list", ")", ":", "edgelist", "=", "[", "edgelist", "]", "teneto", ".", "utils", ".", "check_TemporalNetwork_input", "(", "edgelist", ",", "'edgelist'", ")", "if", "self", ".", "hdf5", ":", "with", "pd", ".", "HDFStore", "(", "self", ".", "network", ")", "as", "hdf", ":", "for", "e", "in", "edgelist", ":", "hdf", ".", "remove", "(", "'network'", ",", "'i == '", "+", "str", "(", "e", "[", "0", "]", ")", "+", "' & '", "+", "'j == '", "+", "str", "(", "e", "[", "1", "]", ")", "+", "' & '", "+", "'t == '", "+", "str", "(", "e", "[", "2", "]", ")", ")", "print", "(", "'HDF5 delete warning. This will not reduce the size of the file.'", ")", "else", ":", "for", "e", "in", "edgelist", ":", "idx", "=", "self", ".", "network", "[", "(", "self", ".", "network", "[", "'i'", "]", "==", "e", "[", "0", "]", ")", "&", "(", "self", ".", "network", "[", "'j'", "]", "==", "e", "[", "1", "]", ")", "&", "(", "self", ".", "network", "[", "'t'", "]", "==", "e", "[", "2", "]", ")", "]", ".", "index", "self", ".", "network", ".", "drop", "(", "idx", ",", "inplace", "=", "True", ")", "self", ".", "network", ".", "reset_index", "(", "inplace", "=", "True", ",", "drop", "=", "True", ")", "self", ".", "_update_network", "(", ")" ]

[ "Removes", "an", "edge", "from", "network", "." ]

[ "def", "calc_networkmeasure", "(", "self", ",", "networkmeasure", ",", "*", "*", "measureparams", ")", ":", "availablemeasures", "=", "[", "f", "for", "f", "in", "dir", "(", "teneto", ".", "networkmeasures", ")", "if", "not", "f", ".", "startswith", "(", "'__'", ")", "]", "if", "networkmeasure", "not", "in", "availablemeasures", ":", "raise", "ValueError", "(", "'Unknown network measure. Available network measures are: '", "+", "', '", ".", "join", "(", "availablemeasures", ")", ")", "funs", "=", "inspect", ".", "getmembers", "(", "teneto", ".", "networkmeasures", ")", "funs", "=", "{", "m", "[", "0", "]", ":", "m", "[", "1", "]", "for", "m", "in", "funs", "if", "not", "m", "[", "0", "]", ".", "startswith", "(", "'__'", ")", "}", "measure", "=", "funs", "[", "networkmeasure", "]", "(", "self", ",", "*", "*", "measureparams", ")", "return", "measure" ]

[ "Calculate", "network", "measure", "." ]

[ "def", "generatenetwork", "(", "self", ",", "networktype", ",", "*", "*", "networkparams", ")", ":", "availabletypes", "=", "[", "f", "for", "f", "in", "dir", "(", "teneto", ".", "generatenetwork", ")", "if", "not", "f", ".", "startswith", "(", "'__'", ")", "]", "if", "networktype", "not", "in", "availabletypes", ":", "raise", "ValueError", "(", "'Unknown network measure. Available networks to generate are: '", "+", "', '", ".", "join", "(", "availabletypes", ")", ")", "funs", "=", "inspect", ".", "getmembers", "(", "teneto", ".", "generatenetwork", ")", "funs", "=", "{", "m", "[", "0", "]", ":", "m", "[", "1", "]", "for", "m", "in", "funs", "if", "not", "m", "[", "0", "]", ".", "startswith", "(", "'__'", ")", "}", "network", "=", "funs", "[", "networktype", "]", "(", "*", "*", "networkparams", ")", "self", ".", "network_from_array", "(", "network", ")", "if", "self", ".", "nettype", "[", "1", "]", "==", "'u'", ":", "self", ".", "_drop_duplicate_ij", "(", ")" ]

[ "Generate", "a", "network" ]

[ "def", "save_aspickle", "(", "self", ",", "fname", ")", ":", "if", "fname", "[", "-", "4", ":", "]", "!=", "'.pkl'", ":", "fname", "+=", "'.pkl'", "with", "open", "(", "fname", ",", "'wb'", ")", "as", "f", ":", "pickle", ".", "dump", "(", "self", ",", "f", ",", "pickle", ".", "HIGHEST_PROTOCOL", ")" ]

[ "Saves", "object", "as", "pickle", "." ]

[ "def", "postpro_fisher", "(", "data", ",", "report", "=", "None", ")", ":", "if", "not", "report", ":", "report", "=", "{", "}", "# Due to rounding errors", "data", "[", "data", "<", "-", "0.99999999999999", "]", "=", "-", "1", "data", "[", "data", ">", "0.99999999999999", "]", "=", "1", "fisher_data", "=", "0.5", "*", "np", ".", "log", "(", "(", "1", "+", "data", ")", "/", "(", "1", "-", "data", ")", ")", "report", "[", "'fisher'", "]", "=", "{", "}", "report", "[", "'fisher'", "]", "[", "'performed'", "]", "=", "'yes'", "#report['fisher']['diagonal'] = 'zeroed'", "return", "fisher_data", ",", "report" ]

[ "Performs", "fisher", "transform", "on", "everything", "in", "data", "." ]

[ "def", "postpro_boxcox", "(", "data", ",", "report", "=", "None", ")", ":", "if", "not", "report", ":", "report", "=", "{", "}", "# Note the min value of all time series will now be at least 1.", "mindata", "=", "1", "-", "np", ".", "nanmin", "(", "data", ")", "data", "=", "data", "+", "mindata", "ind", "=", "np", ".", "triu_indices", "(", "data", ".", "shape", "[", "0", "]", ",", "k", "=", "1", ")", "boxcox_list", "=", "np", ".", "array", "(", "[", "sp", ".", "stats", ".", "boxcox", "(", "np", ".", "squeeze", "(", "data", "[", "ind", "[", "0", "]", "[", "n", "]", ",", "ind", "[", "1", "]", "[", "n", "]", ",", ":", "]", ")", ")", "for", "n", "in", "range", "(", "0", ",", "len", "(", "ind", "[", "0", "]", ")", ")", "]", ")", "boxcox_data", "=", "np", ".", "zeros", "(", "data", ".", "shape", ")", "boxcox_data", "[", "ind", "[", "0", "]", ",", "ind", "[", "1", "]", ",", ":", "]", "=", "np", ".", "vstack", "(", "boxcox_list", "[", ":", ",", "0", "]", ")", "boxcox_data", "[", "ind", "[", "1", "]", ",", "ind", "[", "0", "]", ",", ":", "]", "=", "np", ".", "vstack", "(", "boxcox_list", "[", ":", ",", "0", "]", ")", "bccheck", "=", "np", ".", "array", "(", "np", ".", "transpose", "(", "boxcox_data", ",", "[", "2", ",", "0", ",", "1", "]", ")", ")", "bccheck", "=", "(", "bccheck", "-", "bccheck", ".", "mean", "(", "axis", "=", "0", ")", ")", "/", "bccheck", ".", "std", "(", "axis", "=", "0", ")", "bccheck", "=", "np", ".", "squeeze", "(", "np", ".", "mean", "(", "bccheck", ",", "axis", "=", "0", ")", ")", "np", ".", "fill_diagonal", "(", "bccheck", ",", "0", ")", "report", "[", "'boxcox'", "]", "=", "{", "}", "report", "[", "'boxcox'", "]", "[", "'performed'", "]", "=", "'yes'", "report", "[", "'boxcox'", "]", "[", "'lambda'", "]", "=", "[", "tuple", "(", "[", "ind", "[", "0", "]", "[", "n", "]", ",", "ind", "[", "1", "]", "[", "n", "]", ",", "boxcox_list", "[", "n", ",", "-", "1", "]", "]", ")", "for", "n", "in", "range", "(", "0", ",", "len", "(", "ind", "[", "0", "]", ")", ")", "]", "report", "[", "'boxcox'", "]", "[", "'shift'", "]", "=", "mindata", "report", "[", "'boxcox'", "]", "[", "'shited_to'", "]", "=", "1", "if", "np", ".", "sum", "(", "np", ".", "isnan", "(", "bccheck", ")", ")", ">", "0", ":", "report", "[", "'boxcox'", "]", "=", "{", "}", "report", "[", "'boxcox'", "]", "[", "'performed'", "]", "=", "'FAILED'", "report", "[", "'boxcox'", "]", "[", "'failure_reason'", "]", "=", "(", "'Box cox transform is returning edges with uniform values through time. '", "'This is probabaly due to one or more outliers or a very skewed distribution. '", "'Have you corrected for sources of noise (e.g. movement)? '", "'If yes, some time-series might need additional transforms to approximate to Gaussian.'", ")", "report", "[", "'boxcox'", "]", "[", "'failure_consequence'", "]", "=", "(", "'Box cox transform was skipped from the postprocess pipeline.'", ")", "boxcox_data", "=", "data", "-", "mindata", "error_msg", "=", "(", "'TENETO WARNING: Box Cox transform problem. \\n'", "'Box Cox transform not performed. \\n'", "'See report for more details.'", ")", "print", "(", "error_msg", ")", "return", "boxcox_data", ",", "report" ]

[ "Performs", "box", "cox", "transform", "on", "everything", "in", "data", "." ]

[ "def", "binarize_rdp", "(", "netin", ",", "level", ",", "sign", "=", "'pos'", ",", "axis", "=", "'time'", ")", ":", "netin", ",", "netinfo", "=", "process_input", "(", "netin", ",", "[", "'C'", ",", "'G'", ",", "'TO'", "]", ")", "trajectory", "=", "rdp", "(", "netin", ",", "level", ")", "contacts", "=", "[", "]", "# Use the trajectory points as threshold", "for", "n", "in", "range", "(", "trajectory", "[", "'index'", "]", ".", "shape", "[", "0", "]", ")", ":", "if", "sign", "==", "'pos'", ":", "sel", "=", "trajectory", "[", "'trajectory_points'", "]", "[", "n", "]", "[", "trajectory", "[", "'trajectory'", "]", "[", "n", "]", "[", "trajectory", "[", "'trajectory_points'", "]", "[", "n", "]", "]", ">", "0", "]", "elif", "sign", "==", "'neg'", ":", "sel", "=", "trajectory", "[", "'trajectory_points'", "]", "[", "n", "]", "[", "trajectory", "[", "'trajectory'", "]", "[", "n", "]", "[", "trajectory", "[", "'trajectory_points'", "]", "[", "n", "]", "]", "<", "0", "]", "else", ":", "sel", "=", "trajectory", "[", "'trajectory_points'", "]", "i_ind", "=", "np", ".", "repeat", "(", "trajectory", "[", "'index'", "]", "[", "n", ",", "0", "]", ",", "len", "(", "sel", ")", ")", "j_ind", "=", "np", ".", "repeat", "(", "trajectory", "[", "'index'", "]", "[", "n", ",", "1", "]", ",", "len", "(", "sel", ")", ")", "contacts", ".", "append", "(", "np", ".", "array", "(", "[", "i_ind", ",", "j_ind", ",", "sel", "]", ")", ".", "transpose", "(", ")", ")", "contacts", "=", "np", ".", "concatenate", "(", "contacts", ")", "# Create output dictionary", "netout", "=", "dict", "(", "netinfo", ")", "netout", "[", "'contacts'", "]", "=", "contacts", "netout", "[", "'nettype'", "]", "=", "'b'", "+", "netout", "[", "'nettype'", "]", "[", "1", "]", "netout", "[", "'dimord'", "]", "=", "'node,node,time'", "netout", "[", "'timetype'", "]", "=", "'discrete'", "netout", "[", "'diagonal'", "]", "=", "0", "# If input is graphlet, output graphlet", "if", "netinfo", "[", "'inputtype'", "]", "==", "'G'", ":", "netout", "=", "contact2graphlet", "(", "netout", ")", "else", ":", "netout", ".", "pop", "(", "'inputtype'", ")", "return", "netout" ]

[ "Binarizes", "a", "network", "based", "on", "RDP", "compression", "." ]

[ "def", "binarize", "(", "netin", ",", "threshold_type", ",", "threshold_level", ",", "sign", "=", "'pos'", ",", "axis", "=", "'time'", ")", ":", "if", "threshold_type", "==", "'percent'", ":", "netout", "=", "binarize_percent", "(", "netin", ",", "threshold_level", ",", "sign", ",", "axis", ")", "elif", "threshold_type", "==", "'magnitude'", ":", "netout", "=", "binarize_magnitude", "(", "netin", ",", "threshold_level", ",", "sign", ")", "elif", "threshold_type", "==", "'rdp'", ":", "netout", "=", "binarize_rdp", "(", "netin", ",", "threshold_level", ",", "sign", ",", "axis", ")", "else", ":", "raise", "ValueError", "(", "'Unknown value to parameter: threshold_type.'", ")", "return", "netout" ]

[ "Binarizes", "a", "network", "returning", "the", "network", ".", "General", "wrapper", "function", "for", "different", "binarization", "functions", "." ]

[ "def", "process_input", "(", "netIn", ",", "allowedformats", ",", "outputformat", "=", "'G'", ")", ":", "inputtype", "=", "checkInput", "(", "netIn", ")", "# Convert TN to G representation", "if", "inputtype", "==", "'TN'", "and", "'TN'", "in", "allowedformats", "and", "outputformat", "!=", "'TN'", ":", "G", "=", "netIn", ".", "df_to_array", "(", ")", "netInfo", "=", "{", "'nettype'", ":", "netIn", ".", "nettype", ",", "'netshape'", ":", "netIn", ".", "netshape", "}", "elif", "inputtype", "==", "'TN'", "and", "'TN'", "in", "allowedformats", "and", "outputformat", "==", "'TN'", ":", "TN", "=", "netIn", "elif", "inputtype", "==", "'C'", "and", "'C'", "in", "allowedformats", "and", "outputformat", "==", "'G'", ":", "G", "=", "contact2graphlet", "(", "netIn", ")", "netInfo", "=", "dict", "(", "netIn", ")", "netInfo", ".", "pop", "(", "'contacts'", ")", "elif", "inputtype", "==", "'C'", "and", "'C'", "in", "allowedformats", "and", "outputformat", "==", "'TN'", ":", "TN", "=", "TemporalNetwork", "(", "from_dict", "=", "netIn", ")", "elif", "inputtype", "==", "'G'", "and", "'G'", "in", "allowedformats", "and", "outputformat", "==", "'TN'", ":", "TN", "=", "TemporalNetwork", "(", "from_array", "=", "netIn", ")", "# Get network type if not set yet", "elif", "inputtype", "==", "'G'", "and", "'G'", "in", "allowedformats", ":", "netInfo", "=", "{", "}", "netInfo", "[", "'netshape'", "]", "=", "netIn", ".", "shape", "netInfo", "[", "'nettype'", "]", "=", "gen_nettype", "(", "netIn", ")", "G", "=", "netIn", "elif", "inputtype", "==", "'C'", "and", "outputformat", "==", "'C'", ":", "pass", "else", ":", "raise", "ValueError", "(", "'Input invalid.'", ")", "if", "outputformat", "==", "'TN'", "and", "not", "isinstance", "(", "TN", ".", "network", ",", "str", ")", ":", "TN", ".", "network", "[", "'i'", "]", "=", "TN", ".", "network", "[", "'i'", "]", ".", "astype", "(", "int", ")", "TN", ".", "network", "[", "'j'", "]", "=", "TN", ".", "network", "[", "'j'", "]", ".", "astype", "(", "int", ")", "TN", ".", "network", "[", "'t'", "]", "=", "TN", ".", "network", "[", "'t'", "]", ".", "astype", "(", "int", ")", "if", "outputformat", "==", "'C'", "or", "outputformat", "==", "'G'", ":", "netInfo", "[", "'inputtype'", "]", "=", "inputtype", "if", "inputtype", "!=", "'C'", "and", "outputformat", "==", "'C'", ":", "C", "=", "graphlet2contact", "(", "G", ",", "netInfo", ")", "if", "outputformat", "==", "'G'", ":", "return", "G", ",", "netInfo", "elif", "outputformat", "==", "'C'", ":", "return", "C", "elif", "outputformat", "==", "'TN'", ":", "return", "TN" ]

[ "Takes", "input", "network", "and", "checks", "what", "the", "input", "is", "." ]

[ "def", "clean_community_indexes", "(", "communityID", ")", ":", "communityID", "=", "np", ".", "array", "(", "communityID", ")", "cid_shape", "=", "communityID", ".", "shape", "if", "len", "(", "cid_shape", ")", ">", "1", ":", "communityID", "=", "communityID", ".", "flatten", "(", ")", "new_communityID", "=", "np", ".", "zeros", "(", "len", "(", "communityID", ")", ")", "for", "i", ",", "n", "in", "enumerate", "(", "np", ".", "unique", "(", "communityID", ")", ")", ":", "new_communityID", "[", "communityID", "==", "n", "]", "=", "i", "if", "len", "(", "cid_shape", ")", ">", "1", ":", "new_communityID", "=", "new_communityID", ".", "reshape", "(", "cid_shape", ")", "return", "new_communityID" ]

[ "Takes", "input", "of", "community", "assignments", ".", "Returns", "reindexed", "community", "assignment", "by", "using", "smallest", "numbers", "possible", "." ]

[ "def", "multiple_contacts_get_values", "(", "C", ")", ":", "d", "=", "collections", ".", "OrderedDict", "(", ")", "for", "c", "in", "C", "[", "'contacts'", "]", ":", "ct", "=", "tuple", "(", "c", ")", "if", "ct", "in", "d", ":", "d", "[", "ct", "]", "+=", "1", "else", ":", "d", "[", "ct", "]", "=", "1", "new_contacts", "=", "[", "]", "new_values", "=", "[", "]", "for", "(", "key", ",", "value", ")", "in", "d", ".", "items", "(", ")", ":", "new_values", ".", "append", "(", "value", ")", "new_contacts", ".", "append", "(", "key", ")", "C_out", "=", "C", "C_out", "[", "'contacts'", "]", "=", "new_contacts", "C_out", "[", "'values'", "]", "=", "new_values", "return", "C_out" ]

[ "Given", "an", "contact", "representation", "with", "repeated", "contacts", "this", "function", "removes", "duplicates", "and", "creates", "a", "value" ]

[ "def", "check_distance_funciton_input", "(", "distance_func_name", ",", "netinfo", ")", ":", "if", "distance_func_name", "==", "'default'", "and", "netinfo", "[", "'nettype'", "]", "[", "0", "]", "==", "'b'", ":", "print", "(", "'Default distance funciton specified. As network is binary, using Hamming'", ")", "distance_func_name", "=", "'hamming'", "elif", "distance_func_name", "==", "'default'", "and", "netinfo", "[", "'nettype'", "]", "[", "0", "]", "==", "'w'", ":", "distance_func_name", "=", "'euclidean'", "print", "(", "'Default distance funciton specified. '", "'As network is weighted, using Euclidean'", ")", "return", "distance_func_name" ]

[ "Funciton", "checks", "distance_func_name", "if", "it", "is", "specified", "as", "default", ".", "Then", "given", "the", "type", "of", "the", "network", "selects", "a", "default", "distance", "function", "." ]