From f726262c7d4cae0f94e14490a6de9693d52e4187 Mon Sep 17 00:00:00 2001 From: Petar Bozin Date: Mon, 11 Jan 2021 22:17:15 +0100 Subject: [PATCH 1/2] Aggregated changes - python3 migration --- eventlib/api.py | 18 +-- eventlib/backdoor.py | 15 +-- eventlib/coros.py | 6 +- eventlib/db_pool.py | 8 +- eventlib/exc.py | 6 +- eventlib/green/BaseHTTPServer.py | 7 +- eventlib/green/SocketServer.py | 6 +- eventlib/green/httplib.py | 60 ++++----- eventlib/green/socket.py | 12 +- eventlib/green/ssl.py | 20 +-- eventlib/green/thread.py | 2 +- eventlib/green/threading.py | 27 +++-- eventlib/green/time.py | 2 +- eventlib/green/urllib.py | 116 +++++++++--------- eventlib/green/urllib2.py | 34 +++--- eventlib/greenio.py | 64 ++++++---- eventlib/httpc.py | 18 +-- eventlib/httpd.py | 54 ++++----- eventlib/httpdate.py | 2 +- eventlib/hubs/hub.py | 12 +- eventlib/hubs/poll.py | 2 +- eventlib/hubs/selects.py | 4 +- eventlib/hubs/twistedr.py | 7 +- eventlib/pool.py | 4 +- eventlib/pools.py | 6 +- eventlib/proc.py | 16 +-- eventlib/processes.py | 8 +- eventlib/saranwrap.py | 34 +++--- eventlib/support/greenlets.py | 4 +- eventlib/timer.py | 4 +- eventlib/tpool.py | 12 +- eventlib/twistedutil/__init__.py | 10 +- eventlib/twistedutil/protocol.py | 16 +-- eventlib/twistedutil/protocols/basic.py | 2 +- eventlib/util.py | 14 ++- eventlib/wsgi.py | 46 +++---- examples/connect.py | 6 +- examples/echoserver.py | 10 +- examples/twisted_client.py | 18 +-- examples/twisted_http_proxy.py | 4 +- examples/twisted_portforward.py | 8 +- examples/twisted_server.py | 12 +- examples/twisted_srvconnector.py | 8 +- examples/twisted_xcap_proxy.py | 2 +- greentest/api_test.py | 24 ++-- greentest/coros_test.py | 9 +- greentest/db_pool_test.py | 110 ++++++++--------- greentest/generate_report.py | 14 +-- greentest/greenio_test.py | 4 +- greentest/httpc_test.py | 102 ++++++++-------- greentest/httpd_test.py | 10 +- greentest/parse_results.py | 14 ++- greentest/pools_test.py | 50 ++++---- greentest/processes_test.py | 14 +-- greentest/record_results.py | 16 +-- greentest/runall.py | 16 +-- greentest/saranwrap_test.py | 58 ++++----- greentest/test__api_timeout.py | 4 +- greentest/test__coros_queue.py | 50 ++++---- greentest/test__doctests.py | 4 +- greentest/test__event.py | 2 +- greentest/test__greenness.py | 6 +- greentest/test__pool.py | 12 +- greentest/test__proc.py | 10 +- greentest/test__refcount.py | 10 +- greentest/test__socket_errors.py | 2 +- greentest/test__twistedutil.py | 2 +- greentest/test__twistedutil_protocol.py | 2 +- greentest/test_socket.py | 130 ++++++++++---------- greentest/test_socket_ssl.py | 18 +-- greentest/test_socketserver.py | 34 +++--- greentest/test_support.py | 53 ++++---- greentest/test_thread.py | 42 +++---- greentest/test_thread__boundedsem.py | 2 +- greentest/test_threading.py | 52 ++++---- greentest/test_timeout.py | 22 ++-- greentest/test_urllib2.py | 154 ++++++++++++------------ greentest/test_urllib2_localnet.py | 22 ++-- greentest/tpool_test.py | 30 ++--- greentest/with_eventlet.py | 10 +- greentest/with_timeout.py | 36 +++--- greentest/wsgi_test.py | 22 ++-- setup.py | 2 +- 83 files changed, 975 insertions(+), 945 deletions(-) mode change 100755 => 100644 examples/echoserver.py mode change 100755 => 100644 examples/twisted_portforward.py diff --git a/eventlib/api.py b/eventlib/api.py index 4d4e735..2872de9 100644 --- a/eventlib/api.py +++ b/eventlib/api.py @@ -113,14 +113,14 @@ def tcp_server(listensocket, server, *args, **kw): \*\*kw The keyword arguments to pass to *server*. """ - print "tcpserver spawning %s on %s" % (server, listensocket.getsockname()) + print(("tcpserver spawning %s on %s" % (server, listensocket.getsockname()))) try: try: while True: spawn(server, listensocket.accept(), *args, **kw) - except socket.error, e: + except socket.error as e: # Broken pipe means it was shutdown - if e[0] != 32: + if e.errno != 32: raise finally: listensocket.close() @@ -173,7 +173,7 @@ def get_fileno(obj): try: f = obj.fileno except AttributeError: - assert isinstance(obj, (int, long)) + assert isinstance(obj, int) return obj else: return f() @@ -211,7 +211,7 @@ def on_timeout(): if timeout is not None: t = hub.schedule_call(timeout, on_timeout) try: - for k, v in ds.iteritems(): + for k, v in list(ds.items()): d = hub.add_descriptor(k, v.get('read') is not None and on_read, v.get('write') is not None and on_write, @@ -395,7 +395,7 @@ def with_timeout(seconds, func, *args, **kwds): try: try: return func(*args, **kwds) - except TimeoutError, ex: + except TimeoutError as ex: if ex is error and has_timeout_value: return timeout_value raise @@ -529,7 +529,7 @@ def __call__(self, frame, event, arg): line = 'Unknown code named [%s]. VM instruction #%d' % ( frame.f_code.co_name, frame.f_lasti) if self.trace_names is None or name in self.trace_names: - print '%s:%s: %s' % (name, lineno, line.rstrip()) + print(('%s:%s: %s' % (name, lineno, line.rstrip()))) if not self.show_values: return self details = '\t' @@ -541,7 +541,7 @@ def __call__(self, frame, event, arg): if tok in frame.f_locals: details += '%s=%r ' % (tok, frame.f_locals[tok]) if details.strip(): - print details + print(details) return self @@ -576,7 +576,7 @@ def named(name): try: obj = __import__(toimport) break - except ImportError, err: + except ImportError as err: # print 'Import error on %s: %s' % (toimport, err) # debugging spam import_err_strings.append(err.__str__()) toimport = '.'.join(toimport.split('.')[:-1]) diff --git a/eventlib/backdoor.py b/eventlib/backdoor.py index 1ffb552..8349541 100644 --- a/eventlib/backdoor.py +++ b/eventlib/backdoor.py @@ -53,7 +53,7 @@ def __init__(self, desc, hostport, locals): 'flush': lambda: None, 'readline': lambda *a: readline(*a).replace('\r\n', '\n'), } - for key, value in self.fixups.iteritems(): + for key, value in self.fixups.items(): if hasattr(desc, key): self.old[key] = getattr(desc, key) setattr(desc, key, value) @@ -88,22 +88,22 @@ def finalize(self): self.fixups.clear() self.old.clear() self.desc = None - print "backdoor closed to %s:%s" % self.hostport + print("backdoor closed to %s:%s" % self.hostport) def backdoor_server(server, locals=None): - print "backdoor listening on %s:%s" % server.getsockname() + print("backdoor listening on %s:%s" % server.getsockname()) try: try: while True: (conn, (host, port)) = server.accept() - print "backdoor connected to %s:%s" % (host, port) + print("backdoor connected to %s:%s" % (host, port)) fl = conn.makeGreenFile("rw") fl.newlines = '\n' greenlet = SocketConsole(fl, (host, port), locals) hub = api.get_hub() hub.schedule_call_global(0, greenlet.switch) - except socket.error, e: + except socket.error as e: # Broken pipe means it was shutdown if e[0] != 32: raise @@ -111,15 +111,16 @@ def backdoor_server(server, locals=None): server.close() -def backdoor((conn, addr), locals=None): +def backdoor(connection, locals=None): """ Use this with tcp_server like so: api.tcp_server( api.tcp_listener(('127.0.0.1', 9000)), backdoor.backdoor, {}) """ + (conn, addr) = connection host, port = addr - print "backdoor to %s:%s" % (host, port) + print("backdoor to %s:%s" % (host, port)) fl = conn.makeGreenFile("rw") fl.newlines = '\n' greenlet = SocketConsole(fl, (host, port), locals) diff --git a/eventlib/coros.py b/eventlib/coros.py index 7fc0e01..decb654 100644 --- a/eventlib/coros.py +++ b/eventlib/coros.py @@ -187,7 +187,7 @@ def send(self, result=None, exc=None): self._exc = exc hub = api.get_hub() if self._waiters: - hub.schedule_call_global(0, self._do_send, self._result, self._exc, self._waiters.keys()) + hub.schedule_call_global(0, self._do_send, self._result, self._exc, list(self._waiters.keys())) def _do_send(self, result, exc, waiters): while waiters: @@ -441,7 +441,7 @@ def __init__(self, max_size=None): self.items = collections.deque() self.sem = semaphore(count=0, limit=max_size) - def __nonzero__(self): + def __bool__(self): return len(self.items)>0 def __len__(self): @@ -569,7 +569,7 @@ def received(self, message): def _test(): - print "Running doctests. There will be no further output if they succeed." + print("Running doctests. There will be no further output if they succeed.") import doctest doctest.testmod() diff --git a/eventlib/db_pool.py b/eventlib/db_pool.py index df0c7d9..6f646f3 100644 --- a/eventlib/db_pool.py +++ b/eventlib/db_pool.py @@ -172,7 +172,7 @@ def _schedule_expiration(self): age_delay = (oldest - now) + self.max_age next_delay = min(idle_delay, age_delay) - except IndexError, ValueError: + except IndexError as ValueError: # no free items, unschedule ourselves self._expiration_timer = None return @@ -245,7 +245,7 @@ def _safe_close(self, conn, quiet = False): pass # conn is None, or junk except: if not quiet: - print "Connection.close raised: %s" % (sys.exc_info()[1]) + print("Connection.close raised: %s" % (sys.exc_info()[1])) def get(self): conn = super(BaseConnectionPool, self).get() @@ -297,7 +297,7 @@ def put(self, conn): except: # we don't care what the exception was, we just know the # connection is dead - print "WARNING: connection.rollback raised: %s" % (sys.exc_info()[1]) + print("WARNING: connection.rollback raised: %s" % (sys.exc_info()[1])) conn = None if conn is not None: @@ -443,7 +443,7 @@ def __init__(self, baseconn, pool): super(PooledConnectionWrapper, self).__init__(baseconn) self._pool = pool - def __nonzero__(self): + def __bool__(self): return (hasattr(self, '_base') and bool(self._base)) def _destroy(self): diff --git a/eventlib/exc.py b/eventlib/exc.py index 3626f48..24605ce 100644 --- a/eventlib/exc.py +++ b/eventlib/exc.py @@ -43,9 +43,9 @@ def format_exc(exc=None): f.f_code.co_filename, exc_tb.tb_lineno, [(key, value) for (key, value) - in f.f_locals.items() if key != '__builtins__'], + in list(f.f_locals.items()) if key != '__builtins__'], [(key, value) for (key, value) - in f.f_globals.items() if key != '__builtins__'])) + in list(f.f_globals.items()) if key != '__builtins__'])) exc_tb = exc_tb.tb_next stack_trace = [] @@ -81,7 +81,7 @@ def format_exc(exc=None): for name, var in local_vars: if name == 'self' and hasattr(var, '__dict__'): vars_dict['self'] = dict([ - (key, value) for (key, value) in var.__dict__.items() + (key, value) for (key, value) in list(var.__dict__.items()) if re.search( r'\Wself.%s\W' % (re.escape(key),), code_text)]) break diff --git a/eventlib/green/BaseHTTPServer.py b/eventlib/green/BaseHTTPServer.py index 8ebc4ab..36a2fe4 100644 --- a/eventlib/green/BaseHTTPServer.py +++ b/eventlib/green/BaseHTTPServer.py @@ -2,10 +2,7 @@ from eventlib.green import socket from eventlib.green import SocketServer -__import_lst = ['DEFAULT_ERROR_MESSAGE', '_quote_html', '__version__', '__all__', 'BaseHTTPRequestHandler'] -__BaseHTTPServer = __import__('BaseHTTPServer') -for var in __import_lst: - exec "%s = __BaseHTTPServer.%s" % (var, var) +from http.server import( DEFAULT_ERROR_MESSAGE, __version__, __all__, BaseHTTPRequestHandler) class HTTPServer(SocketServer.TCPServer): @@ -46,7 +43,7 @@ def test(HandlerClass = BaseHTTPRequestHandler, httpd = ServerClass(server_address, HandlerClass) sa = httpd.socket.getsockname() - print "Serving HTTP on", sa[0], "port", sa[1], "..." + print("Serving HTTP on", sa[0], "port", sa[1], "...") httpd.serve_forever() diff --git a/eventlib/green/SocketServer.py b/eventlib/green/SocketServer.py index d8d6c78..8b0f887 100644 --- a/eventlib/green/SocketServer.py +++ b/eventlib/green/SocketServer.py @@ -1,8 +1,4 @@ -__import_lst = ['__all__', '__version__', 'BaseServer', 'TCPServer', 'UDPServer', 'ForkingMixIn', - 'ThreadingMixIn', 'BaseRequestHandler', 'StreamRequestHandler', 'DatagramRequestHandler'] -__SocketServer = __import__('SocketServer') -for var in __import_lst: - exec "%s = __SocketServer.%s" % (var, var) +from socketserver import( __all__, __version__, BaseServer, TCPServer, UDPServer, ForkingMixIn, ThreadingMixIn, BaseRequestHandler, StreamRequestHandler, DatagramRequestHandler ) # QQQ ForkingMixIn should be fixed to use green waitpid? diff --git a/eventlib/green/httplib.py b/eventlib/green/httplib.py index 65a1305..e3beee1 100644 --- a/eventlib/green/httplib.py +++ b/eventlib/green/httplib.py @@ -67,14 +67,14 @@ """ import errno -import mimetools +from email.message import Message from eventlib.green import socket -from urlparse import urlsplit +from urllib.parse import urlsplit try: - from cStringIO import StringIO + from io import StringIO except ImportError: - from StringIO import StringIO + from io import StringIO __all__ = ["HTTP", "HTTPResponse", "HTTPConnection", "HTTPSConnection", "HTTPException", "NotConnected", "UnknownProtocol", @@ -205,7 +205,7 @@ # maximal amount of data to read at one time in _safe_read MAXAMOUNT = 1048576 -class HTTPMessage(mimetools.Message): +class HTTPMessage(Message): def addheader(self, key, value): """Add header for field key handling repeats.""" @@ -342,7 +342,7 @@ def _read_status(self): # Initialize with Simple-Response defaults line = self.fp.readline() if self.debuglevel > 0: - print "reply:", repr(line) + print("reply:", repr(line)) if not line: # Presumably, the server closed the connection before # sending a valid response. @@ -391,7 +391,7 @@ def begin(self): if not skip: break if self.debuglevel > 0: - print "header:", skip + print("header:", skip) self.status = status self.reason = reason.strip() @@ -414,7 +414,7 @@ def begin(self): self.msg = HTTPMessage(self.fp, 0) if self.debuglevel > 0: for hdr in self.msg.headers: - print "header:", hdr, + print("header:", hdr, end=' ') # don't let the msg keep an fp self.msg.fp = None @@ -615,7 +615,7 @@ def getheaders(self): """Return list of (header, value) tuples.""" if self.msg is None: raise ResponseNotReady() - return self.msg.items() + return list(self.msg.items()) class HTTPConnection: @@ -688,10 +688,10 @@ def send(self, str): # NOTE: we DO propagate the error, though, because we cannot simply # ignore the error... the caller will know if they can retry. if self.debuglevel > 0: - print "send:", repr(str) + print("send:", repr(str)) try: self.sock.sendall(str) - except socket.error, v: + except socket.error as v: if v[0] == 32: # Broken pipe self.close() raise @@ -846,7 +846,7 @@ def request(self, method, url, body=None, headers={}): try: self._send_request(method, url, body, headers) - except socket.error, v: + except socket.error as v: # trap 'Broken pipe' if we're allowed to automatically reconnect if v.args[0] != 32 or not self.auto_open: raise @@ -866,7 +866,7 @@ def _send_request(self, method, url, body, headers): if body and ('content-length' not in header_names): self.putheader('Content-Length', str(len(body))) - for hdr, value in headers.iteritems(): + for hdr, value in headers.items(): self.putheader(hdr, value) self.endheaders() @@ -983,7 +983,7 @@ def _read(self): while True: try: buf = self._ssl.read(self._bufsize) - except socket.sslerror, err: + except socket.sslerror as err: if (err[0] == socket.SSL_ERROR_WANT_READ or err[0] == socket.SSL_ERROR_WANT_WRITE): continue @@ -991,7 +991,7 @@ def _read(self): or err[0] == socket.SSL_ERROR_EOF): break raise - except socket.error, err: + except socket.error as err: if err[0] == errno.EINTR: continue if err[0] == errno.EBADF: @@ -1060,7 +1060,7 @@ def fileno(self): def __iter__(self): return self - def next(self): + def __next__(self): line = self.readline() if not line: raise StopIteration @@ -1175,7 +1175,7 @@ def getreply(self): """ try: response = self._conn.getresponse() - except BadStatusLine, e: + except BadStatusLine as e: ### hmm. if getresponse() ever closes the socket on a bad request, ### then we are going to have problems with self.sock @@ -1368,13 +1368,13 @@ def test(): h.putrequest('GET', selector) h.endheaders() status, reason, headers = h.getreply() - print 'status =', status - print 'reason =', reason - print "read", len(h.getfile().read()) - print + print('status =', status) + print('reason =', reason) + print("read", len(h.getfile().read())) + print() if headers: - for header in headers.headers: print header.strip() - print + for header in headers.headers: print(header.strip()) + print() # minimal test that code to extract host from url works class HTTP11(HTTP): @@ -1391,20 +1391,20 @@ class HTTP11(HTTP): for host, selector in (('sourceforge.net', '/projects/python'), ): - print "https://%s%s" % (host, selector) + print("https://%s%s" % (host, selector)) hs = HTTPS() hs.set_debuglevel(dl) hs.connect(host) hs.putrequest('GET', selector) hs.endheaders() status, reason, headers = hs.getreply() - print 'status =', status - print 'reason =', reason - print "read", len(hs.getfile().read()) - print + print('status =', status) + print('reason =', reason) + print("read", len(hs.getfile().read())) + print() if headers: - for header in headers.headers: print header.strip() - print + for header in headers.headers: print(header.strip()) + print() if __name__ == '__main__': test() diff --git a/eventlib/green/socket.py b/eventlib/green/socket.py index add847f..60d3248 100644 --- a/eventlib/green/socket.py +++ b/eventlib/green/socket.py @@ -1,15 +1,13 @@ -__socket = __import__('socket') -for var in __socket.__all__: - exec "%s = __socket.%s" % (var, var) -_fileobject = __socket._fileobject +import socket as __socket +from socket import (__all__, error, AF_INET, SOCK_STREAM, SOL_SOCKET, SO_REUSEADDR, getdefaulttimeout, gethostname, getnameinfo, getservbyname, herror, htonl, SOCK_DGRAM, timeout, gaierror, SOCK_RAW, setdefaulttimeout, getservbyport, gethostbyaddr, ntohl, htons, ntohs, getfqdn, SOCK_RDM, SOCK_SEQPACKET) from eventlib.api import get_hub from eventlib.greenio import GreenSocket as socket from eventlib.greenio import socketpair, fromfd +from socket import SocketIO import warnings - def gethostbyname(name): if getattr(get_hub(), 'uses_twisted_reactor', None): globals()['gethostbyname'] = _gethostbyname_twisted @@ -74,11 +72,11 @@ def create_connection(address, timeout=_GLOBAL_DEFAULT_TIMEOUT): sock.connect(sa) return sock - except error, msg: + except error as msg: if sock is not None: sock.close() - raise error, msg + raise error(msg) try: diff --git a/eventlib/green/ssl.py b/eventlib/green/ssl.py index 6439957..8accc08 100644 --- a/eventlib/green/ssl.py +++ b/eventlib/green/ssl.py @@ -1,11 +1,10 @@ -__ssl = __import__('ssl') -for var in (var for var in dir(__ssl) if not var.startswith('__')): - exec "%s = __ssl.%s" % (var, var) -del var +import ssl as __ssl +from ssl import _ssl +from _ssl import ( RAND_add, RAND_status, SSL_ERROR_ZERO_RETURN, SSL_ERROR_WANT_READ, SSL_ERROR_WANT_WRITE, SSL_ERROR_WANT_X509_LOOKUP, SSL_ERROR_SYSCALL, SSL_ERROR_SSL, SSL_ERROR_WANT_CONNECT, SSL_ERROR_EOF, SSL_ERROR_INVALID_ERROR_CODE, SSLError ) time = __import__('time') from eventlib.api import trampoline -from eventlib.greenio import set_nonblocking, GreenSocket, CONNECT_ERR, CONNECT_SUCCESS, BLOCKING_ERR +from eventlib.greenio import ( set_nonblocking, GreenSocket, GreenFile, CONNECT_ERR, CONNECT_SUCCESS, BLOCKING_ERR ) orig_socket = __import__('socket') socket = orig_socket.socket @@ -66,7 +65,7 @@ def _call_trampolining(self, func, *a, **kw): while True: try: return func(*a, **kw) - except SSLError, e: + except SSLError as e: if e.args[0] == SSL_ERROR_WANT_READ: trampoline(self, read=True, @@ -93,6 +92,8 @@ def read(self, len=1024): super(GreenSSLSocket, self).read, len) def send (self, data, flags=0): + if not isinstance(data, bytes): + data = data.encode() if self._sslobj: return self._call_trampolining( super(GreenSSLSocket, self).send, data, flags) @@ -172,7 +173,7 @@ def _socket_connect(self, addr): while True: try: return real_connect(self, addr) - except orig_socket.error, e: + except orig_socket.error as e: if e.args[0] in CONNECT_ERR: trampoline(self, write=True) elif e.args[0] in CONNECT_SUCCESS: @@ -184,7 +185,7 @@ def _socket_connect(self, addr): while True: try: real_connect(self, addr) - except orig_socket.error, e: + except orig_socket.error as e: if e.args[0] in CONNECT_ERR: trampoline(self, write=True, timeout=end-time.time(), timeout_exc=SSLError('timed out')) elif e.args[0] in CONNECT_SUCCESS: @@ -221,7 +222,7 @@ def accept(self): newsock, addr = socket.accept(self) set_nonblocking(newsock) break - except orig_socket.error, e: + except orig_socket.error as e: if e.args[0] not in BLOCKING_ERR: raise trampoline(self, read=True, timeout=self.gettimeout(), timeout_exc=SSLError('timed out')) @@ -255,5 +256,6 @@ def sslwrap_simple(sock, keyfile=None, certfile=None): server_side=False, cert_reqs=CERT_NONE, ssl_version=PROTOCOL_SSLv23, + do_handshake_on_connect=False, ca_certs=None) return ssl_sock diff --git a/eventlib/green/thread.py b/eventlib/green/thread.py index 9ff5370..4e19059 100644 --- a/eventlib/green/thread.py +++ b/eventlib/green/thread.py @@ -1,5 +1,5 @@ """implements standard module 'thread' with greenlets""" -__thread = __import__('thread') +__thread = __import__('_thread') from eventlib.support import greenlets as greenlet from eventlib.api import spawn from eventlib.coros import Semaphore as LockType diff --git a/eventlib/green/threading.py b/eventlib/green/threading.py index 127b84c..c53c703 100644 --- a/eventlib/green/threading.py +++ b/eventlib/green/threading.py @@ -123,7 +123,8 @@ def __exit__(self, t, v, tb): # Internal methods used by condition variables - def _acquire_restore(self, (count, owner)): + def _acquire_restore(self, state): + (count, owner) = state self.__block.acquire() self.__count = count self.__owner = owner @@ -321,7 +322,7 @@ def __init__(self, value=1, verbose=None): def release(self): if self._Semaphore__value >= self._initial_value: - raise ValueError, "Semaphore released too many times" + raise ValueError("Semaphore released too many times") return _Semaphore.release(self) @@ -497,19 +498,19 @@ def __bootstrap_inner(self): # Lib/traceback.py) exc_type, exc_value, exc_tb = self.__exc_info() try: - print>>self.__stderr, ( + print(( "Exception in thread " + self.getName() + - " (most likely raised during interpreter shutdown):") - print>>self.__stderr, ( - "Traceback (most recent call last):") + " (most likely raised during interpreter shutdown):"), file=self.__stderr) + print(( + "Traceback (most recent call last):"), file=self.__stderr) while exc_tb: - print>>self.__stderr, ( + print(( ' File "%s", line %s, in %s' % (exc_tb.tb_frame.f_code.co_filename, exc_tb.tb_lineno, - exc_tb.tb_frame.f_code.co_name)) + exc_tb.tb_frame.f_code.co_name)), file=self.__stderr) exc_tb = exc_tb.tb_next - print>>self.__stderr, ("%s: %s" % (exc_type, exc_value)) + print(("%s: %s" % (exc_type, exc_value)), file=self.__stderr) # Make sure that exc_tb gets deleted since it is a memory # hog; deleting everything else is just for thoroughness finally: @@ -739,12 +740,12 @@ def activeCount(): def enumerate(): _active_limbo_lock.acquire() - active = _active.values() + _limbo.values() + active = list(_active.values()) + list(_limbo.values()) _active_limbo_lock.release() return active try: - from thread import stack_size + from .thread import stack_size __all__.append('stack_size') except ImportError: pass @@ -759,7 +760,7 @@ def enumerate(): # module, or from the python fallback try: - from thread import _local as local + from .thread import _local as local except ImportError: from _threading_local import local @@ -826,7 +827,7 @@ def __init__(self, queue, count): def run(self): while self.count > 0: item = self.queue.get() - print item + print(item) self.count = self.count - 1 NP = 3 diff --git a/eventlib/green/time.py b/eventlib/green/time.py index a4f42a9..922883d 100644 --- a/eventlib/green/time.py +++ b/eventlib/green/time.py @@ -1,4 +1,4 @@ __time = __import__('time') for var in dir(__time): - exec "%s = __time.%s" % (var, var) + exec("%s = __time.%s" % (var, var)) from eventlib.api import sleep diff --git a/eventlib/green/urllib.py b/eventlib/green/urllib.py index af1f20a..924b079 100644 --- a/eventlib/green/urllib.py +++ b/eventlib/green/urllib.py @@ -1,21 +1,15 @@ -urllib = __import__('urllib') -for var in dir(urllib): - exec "%s = urllib.%s" % (var, var) - -# import the following to be a better drop-in replacement -__import_lst = ['__all__', '__version__', 'MAXFTPCACHE', 'ContentTooShortError', - 'ftpcache', '_noheaders', 'noheaders', 'addbase', 'addclosehook', - 'addinfo', 'addinfourl', '_is_unicode', 'toBytes', '_hextochr', - 'always_safe', 'getproxies_environment', 'proxy_bypass'] - -for var in __import_lst: - exec "%s = urllib.%s" % (var, var) - -from eventlib.green import socket import os -from eventlib.green import time import sys -from urlparse import urljoin as basejoin +import urllib +from eventlib.green import socket, time +from urllib.error import( __all__ ) +from urllib.response import( __all__ ) +from urllib.robotparser import( __all__ ) +from urllib.request import( __all__, __version__, MAXFTPCACHE, ftpcache, ftpwrapper, _noheaders, noheaders, proxy_bypass ) +from urllib.parse import( __all__, splithost, splituser, splittype, splitattr, splitpasswd, splitport, splitquery, splitvalue) +from urllib.parse import urljoin as basejoin + +parse = urllib.parse.parse_qs # Shortcut for basic usage _urlopener = None @@ -42,7 +36,7 @@ def urlcleanup(): if _urlopener: _urlopener.cleanup() -class URLopener(urllib.URLopener): +class URLopener(urllib.request.URLopener): def open_http(self, url, data=None): """Use HTTP protocol.""" @@ -75,7 +69,7 @@ def open_http(self, url, data=None): host = realhost #print "proxy via http:", host, selector - if not host: raise IOError, ('http error', 'no host given') + if not host: raise IOError('http error', 'no host given') if proxy_passwd: import base64 @@ -105,7 +99,7 @@ def open_http(self, url, data=None): errcode, errmsg, headers = h.getreply() if errcode == -1: # something went wrong with the HTTP status line - raise IOError, ('http protocol error', 0, + raise IOError('http protocol error', 0, 'got a bad status line', None) fp = h.getfile() if errcode == 200: @@ -144,7 +138,7 @@ def open_https(self, url, data=None): if user_passwd: selector = "%s://%s%s" % (urltype, realhost, rest) #print "proxy via https:", host, selector - if not host: raise IOError, ('https error', 'no host given') + if not host: raise IOError('https error', 'no host given') if proxy_passwd: import base64 proxy_auth = base64.b64encode(proxy_passwd).strip() @@ -175,7 +169,7 @@ def open_https(self, url, data=None): errcode, errmsg, headers = h.getreply() if errcode == -1: # something went wrong with the HTTP status line - raise IOError, ('http protocol error', 0, + raise IOError('http protocol error', 0, 'got a bad status line', None) fp = h.getfile() if errcode == 200: @@ -190,10 +184,10 @@ def open_https(self, url, data=None): def open_gopher(self, url): """Use Gopher protocol.""" if not isinstance(url, str): - raise IOError, ('gopher error', 'proxy support for gopher protocol currently not implemented') + raise IOError('gopher error', 'proxy support for gopher protocol currently not implemented') from eventlib.green import gopherlib host, selector = splithost(url) - if not host: raise IOError, ('gopher error', 'no host given') + if not host: raise IOError('gopher error', 'no host given') host = unquote(host) type, selector = splitgophertype(selector) selector, query = splitquery(selector) @@ -209,14 +203,14 @@ def open_local_file(self, url): """Use local file.""" import mimetypes, mimetools, email.Utils try: - from cStringIO import StringIO + from io import StringIO except ImportError: - from StringIO import StringIO + from io import StringIO host, file = splithost(url) localname = url2pathname(file) try: stats = os.stat(localname) - except OSError, e: + except OSError as e: raise IOError(e.errno, e.strerror, e.filename) size = stats.st_size modified = email.Utils.formatdate(stats.st_mtime, usegmt=True) @@ -238,19 +232,19 @@ def open_local_file(self, url): urlfile = 'file://' + file return addinfourl(open(localname, 'rb'), headers, urlfile) - raise IOError, ('local file error', 'not on local host') + raise IOError('local file error', 'not on local host') def open_ftp(self, url): """Use FTP protocol.""" if not isinstance(url, str): - raise IOError, ('ftp error', 'proxy support for ftp protocol currently not implemented') + raise IOError('ftp error', 'proxy support for ftp protocol currently not implemented') import mimetypes, mimetools try: - from cStringIO import StringIO + from io import StringIO except ImportError: - from StringIO import StringIO + from io import StringIO host, path = splithost(url) - if not host: raise IOError, ('ftp error', 'no host given') + if not host: raise IOError('ftp error', 'no host given') host, port = splitport(host) user, host = splituser(host) if user: user, passwd = splitpasswd(user) @@ -274,7 +268,7 @@ def open_ftp(self, url): # XXX thread unsafe! if len(self.ftpcache) > MAXFTPCACHE: # Prune the cache, rather arbitrarily - for k in self.ftpcache.keys(): + for k in list(self.ftpcache.keys()): if k != key: v = self.ftpcache[k] del self.ftpcache[k] @@ -299,8 +293,8 @@ def open_ftp(self, url): headers += "Content-Length: %d\n" % retrlen headers = mimetools.Message(StringIO(headers)) return addinfourl(fp, headers, "ftp:" + url) - except ftperrors(), msg: - raise IOError, ('ftp error', msg), sys.exc_info()[2] + except ftperrors() as msg: + raise IOError('ftp error', msg).with_traceback(sys.exc_info()[2]) # this one is copied verbatim class FancyURLopener(URLopener): @@ -479,13 +473,13 @@ def prompt_user_passwd(self, host, realm): """Override this in a GUI environment!""" import getpass try: - user = raw_input("Enter username for %s at %s: " % (realm, + user = input("Enter username for %s at %s: " % (realm, host)) passwd = getpass.getpass("Enter password for %s in %s at %s: " % (user, realm, host)) return user, passwd except KeyboardInterrupt: - print + print() return None, None @@ -519,7 +513,7 @@ def ftperrors(): # Utility classes -class ftpwrapper(urllib.ftpwrapper): +class ftpwrapper(ftpwrapper): """Class used by open_ftp() for cache of open FTP connections.""" def init(self): @@ -547,9 +541,9 @@ def retrfile(self, file, type): try: cmd = 'RETR ' + file conn = self.ftp.ntransfercmd(cmd) - except ftplib.error_perm, reason: + except ftplib.error_perm as reason: if str(reason)[:3] != '550': - raise IOError, ('ftp error', reason), sys.exc_info()[2] + raise IOError('ftp error', reason).with_traceback(sys.exc_info()[2]) if not conn: # Set transfer mode to ASCII! self.ftp.voidcmd('TYPE A') @@ -572,17 +566,17 @@ def test1(): uqs = unquote(qs) t1 = time.time() if uqs != s: - print 'Wrong!' - print repr(s) - print repr(qs) - print repr(uqs) - print round(t1 - t0, 3), 'sec' + print('Wrong!') + print(repr(s)) + print(repr(qs)) + print(repr(uqs)) + print(round(t1 - t0, 3), 'sec') def reporthook(blocknum, blocksize, totalsize): # Report during remote transfers - print "Block number: %d, Block size: %d, Total size: %d" % ( - blocknum, blocksize, totalsize) + print("Block number: %d, Block size: %d, Total size: %d" % ( + blocknum, blocksize, totalsize)) # Test program def test(args=[]): @@ -599,22 +593,22 @@ def test(args=[]): args.append('https://synergy.as.cmu.edu/~geek/') try: for url in args: - print '-'*10, url, '-'*10 + print('-'*10, url, '-'*10) fn, h = urlretrieve(url, None, reporthook) - print fn + print(fn) if h: - print '======' - for k in h.keys(): print k + ':', h[k] - print '======' + print('======') + for k in list(h.keys()): print(k + ':', h[k]) + print('======') fp = open(fn, 'rb') data = fp.read() del fp if '\r' in data: table = string.maketrans("", "") data = data.translate(table, "\r") - print data + print(data) fn, h = None, None - print '-'*40 + print('-'*40) finally: urlcleanup() @@ -622,18 +616,18 @@ def main(): import getopt, sys try: opts, args = getopt.getopt(sys.argv[1:], "th") - except getopt.error, msg: - print msg - print "Use -h for help" + except getopt.error as msg: + print(msg) + print("Use -h for help") return t = 0 for o, a in opts: if o == '-t': t = t + 1 if o == '-h': - print "Usage: python urllib.py [-t] [url ...]" - print "-t runs self-test;", - print "otherwise, contents of urls are printed" + print("Usage: python urllib.py [-t] [url ...]") + print("-t runs self-test;", end=' ') + print("otherwise, contents of urls are printed") return if t: if t > 1: @@ -641,9 +635,9 @@ def main(): test(args) else: if not args: - print "Use -h for help" + print("Use -h for help") for url in args: - print urlopen(url).read(), + print(urlopen(url).read(), end=' ') # Run test program when run as a script if __name__ == '__main__': diff --git a/eventlib/green/urllib2.py b/eventlib/green/urllib2.py index 05d0f5d..11a27c8 100644 --- a/eventlib/green/urllib2.py +++ b/eventlib/green/urllib2.py @@ -1,12 +1,12 @@ urllib2 = __import__('urllib2') for var in dir(urllib2): - exec "%s = urllib2.%s" % (var, var) + exec("%s = urllib2.%s" % (var, var)) # import the following to be a better drop-in replacement __import_lst = ['__version__', '__cut_port_re', '_parse_proxy'] for var in __import_lst: - exec "%s = getattr(urllib2, %r, None)" % (var, var) + exec("%s = getattr(urllib2, %r, None)" % (var, var)) for x in ('urlopen', 'install_opener', 'build_opener', 'HTTPHandler', 'HTTPSHandler', 'HTTPCookieProcessor', 'FileHandler', 'FTPHandler', 'CacheFTPHandler', 'GopherError'): @@ -20,9 +20,9 @@ from eventlib.green import time try: - from cStringIO import StringIO + from io import StringIO except ImportError: - from StringIO import StringIO + from io import StringIO from eventlib.green.urllib import (unwrap, unquote, splittype, splithost, quote, addinfourl, splitport, splitquery, @@ -45,7 +45,7 @@ def install_opener(opener): def build_opener(*handlers): import types def isclass(obj): - return isinstance(obj, types.ClassType) or hasattr(obj, "__bases__") + return isinstance(obj, type) or hasattr(obj, "__bases__") opener = OpenerDirector() default_classes = [ProxyHandler, UnknownHandler, HTTPHandler, @@ -73,7 +73,7 @@ def isclass(obj): opener.add_handler(h) return opener -class HTTPHandler(urllib2.HTTPHandler): +class HTTPHandler(urllib.request.HTTPHandler): def http_open(self, req): return self.do_open(httplib.HTTPConnection, req) @@ -81,21 +81,21 @@ def http_open(self, req): http_request = AbstractHTTPHandler.do_request_ if hasattr(urllib2, 'HTTPSHandler'): - class HTTPSHandler(urllib2.HTTPSHandler): + class HTTPSHandler(urllib.request.HTTPSHandler): def https_open(self, req): return self.do_open(httplib.HTTPSConnection, req) https_request = AbstractHTTPHandler.do_request_ -class HTTPCookieProcessor(urllib2.HTTPCookieProcessor): +class HTTPCookieProcessor(urllib.request.HTTPCookieProcessor): def __init__(self, cookiejar=None): from eventlib.green import cookielib if cookiejar is None: cookiejar = cookielib.CookieJar() self.cookiejar = cookiejar -class FileHandler(urllib2.FileHandler): +class FileHandler(urllib.request.FileHandler): def get_names(self): if FileHandler.names is None: @@ -127,13 +127,13 @@ def open_local_file(self, req): headers, 'file:'+file) raise URLError('file not on local host') -class FTPHandler(urllib2.FTPHandler): +class FTPHandler(urllib.request.FTPHandler): def ftp_open(self, req): from eventlib.green import ftplib import mimetypes host = req.get_host() if not host: - raise IOError, ('ftp error', 'no host given') + raise IOError('ftp error', 'no host given') host, port = splitport(host) if port is None: port = ftplib.FTP_PORT @@ -152,11 +152,11 @@ def ftp_open(self, req): try: host = socket.gethostbyname(host) - except socket.error, msg: + except socket.error as msg: raise URLError(msg) path, attrs = splitattr(req.get_selector()) dirs = path.split('/') - dirs = map(unquote, dirs) + dirs = list(map(unquote, dirs)) dirs, file = dirs[:-1], dirs[-1] if dirs and not dirs[0]: dirs = dirs[1:] @@ -178,8 +178,8 @@ def ftp_open(self, req): sf = StringIO(headers) headers = mimetools.Message(sf) return addinfourl(fp, headers, req.get_full_url()) - except ftplib.all_errors, msg: - raise IOError, ('ftp error', msg), sys.exc_info()[2] + except ftplib.all_errors as msg: + raise IOError('ftp error', msg).with_traceback(sys.exc_info()[2]) def connect_ftp(self, user, passwd, host, port, dirs): fw = ftpwrapper(user, passwd, host, port, dirs) @@ -216,7 +216,7 @@ def check_cache(self): # first check for old ones t = time.time() if self.soonest <= t: - for k, v in self.timeout.items(): + for k, v in list(self.timeout.items()): if v < t: self.cache[k].close() del self.cache[k] @@ -225,7 +225,7 @@ def check_cache(self): # then check the size if len(self.cache) == self.max_conns: - for k, v in self.timeout.items(): + for k, v in list(self.timeout.items()): if v == self.soonest: del self.cache[k] del self.timeout[k] diff --git a/eventlib/greenio.py b/eventlib/greenio.py index 8a7f2c2..e762592 100644 --- a/eventlib/greenio.py +++ b/eventlib/greenio.py @@ -42,33 +42,35 @@ def recv(self, buflen): chunk, self.recvbuffer = buf[:buflen], buf[buflen:] return chunk fd = self.fd - bytes = recv_func(fd, buflen) + _bytes = recv_func(fd, buflen) if self.gettimeout(): end = time.time()+self.gettimeout() else: end = None timeout = None - while bytes is None: + while _bytes is None: try: if end: timeout = end - time.time() trampoline(fd, read=True, timeout=timeout, timeout_exc=socket.timeout) except socket.timeout: raise - except socket.error, e: + except socket.error as e: if e[0] == errno.EPIPE: - bytes = '' + _bytes = b'' else: raise else: - bytes = recv_func(fd, buflen) - self.recvcount += len(bytes) - return bytes + _bytes = recv_func(fd, buflen) + self.recvcount += len(_bytes) + return _bytes return recv def higher_order_send(send_func): def send(self, data): + if not isinstance(data, bytes): + data = data.encode() if self.act_non_blocking: return self.fd.send(data) count = send_func(self.fd, data) @@ -102,17 +104,17 @@ def socket_connect(descriptor, address): def socket_accept(descriptor): try: return descriptor.accept() - except socket.error, e: + except socket.error as e: if e.args[0] in BLOCKING_ERR: return None raise -def socket_send(descriptor, data): +def socket_send(descriptor, data:bytes): try: return descriptor.send(data) - except socket.error, e: - if e.args[0] in BLOCKING_ERR + errno.ENOTCONN: + except socket.error as e: + if e.args[0] in BLOCKING_ERR + (errno.ENOTCONN, ): return 0 raise @@ -121,7 +123,7 @@ def socket_send(descriptor, data): def socket_recv(descriptor, buflen): try: return descriptor.recv(buflen) - except socket.error, e: + except socket.error as e: if e.args[0] in BLOCKING_ERR: return None if e.args[0] in SOCKET_CLOSED: @@ -132,11 +134,11 @@ def socket_recv(descriptor, buflen): def file_recv(fd, buflen): try: return fd.read(buflen) - except IOError, e: + except IOError as e: if e[0] == errno.EAGAIN: return None return '' - except socket.error, e: + except socket.error as e: if e[0] == errno.EPIPE: return '' raise @@ -147,12 +149,12 @@ def file_send(fd, data): fd.write(data) fd.flush() return len(data) - except IOError, e: + except IOError as e: if e[0] == errno.EAGAIN: return 0 - except ValueError, e: + except ValueError as e: written = 0 - except socket.error, e: + except socket.error as e: if e[0] == errno.EPIPE: written = 0 @@ -175,7 +177,7 @@ class GreenSocket(object): is_secure = False timeout = None def __init__(self, family_or_realsock=socket.AF_INET, *args, **kwargs): - if isinstance(family_or_realsock, (int, long)): + if isinstance(family_or_realsock, int): fd = _original_socket(family_or_realsock, *args, **kwargs) else: fd = family_or_realsock @@ -187,7 +189,7 @@ def __init__(self, family_or_realsock=socket.AF_INET, *args, **kwargs): self._fileno = fd.fileno() self.sendcount = 0 self.recvcount = 0 - self.recvbuffer = '' + self.recvbuffer = b'' self.closed = False self.timeout = socket.getdefaulttimeout() @@ -223,6 +225,11 @@ def bind(self, *args, **kw): fn = self.bind = self.fd.bind return fn(*args, **kw) + + def _decref_socketios(self): + if self.closed: + self.close() + def close(self, *args, **kw): if self.closed: return @@ -266,7 +273,7 @@ def connect_ex(self, address): while not socket_connect(fd, address): try: trampoline(fd, write=True, timeout_exc=socket.timeout) - except socket.error, ex: + except socket.error as ex: return ex[0] else: end = time.time() + self.gettimeout() @@ -277,7 +284,7 @@ def connect_ex(self, address): raise socket.timeout try: trampoline(fd, write=True, timeout=end-time.time(), timeout_exc=socket.timeout) - except socket.error, ex: + except socket.error as ex: return ex[0] def dup(self, *args, **kw): @@ -308,7 +315,7 @@ def listen(self, *args, **kw): return fn(*args, **kw) def makefile(self, mode='r', bufsize=-1): - return socket._fileobject(self.dup(), mode, bufsize) + return socket.SocketIO(self.dup(), mode) def makeGreenFile(self, mode='r', bufsize=-1): return GreenFile(self.dup()) @@ -382,7 +389,7 @@ def gettimeout(self): return self.timeout def read(self, size=None): - if size is not None and not isinstance(size, (int, long)): + if size is not None and not isinstance(size, int): raise TypeError('Expecting an int or long for size, got %s: %s' % (type(size), repr(size))) buf, self.sock.recvbuffer = self.sock.recvbuffer, '' lst = [buf] @@ -407,7 +414,12 @@ def read(self, size=None): lst[-1], self.sock.recvbuffer = d[:-overbite], d[-overbite:] else: lst[-1], self.sock.recvbuffer = d, '' - return ''.join(lst) + if isinstance(lst[0], bytes): + stringlst = [x.decode('utf-8') for x in lst] + return ''.join(stringlst) + else: + return ''.join(lst) + class GreenFile(object): @@ -442,7 +454,7 @@ def readuntil(self, terminator, size=None): checked = 0 if size is None: while True: - found = buf.find(terminator, checked) + found = buf.find(terminator.encode(), checked) if found != -1: found += len(terminator) chunk, self.sock.recvbuffer = buf[:found], buf[found:] @@ -471,7 +483,7 @@ def readline(self, size=None): return self.readuntil(self.newlines, size=size) def __iter__(self): - return self.xreadlines() + return self def readlines(self, size=None): return list(self.xreadlines(size=size)) diff --git a/eventlib/httpc.py b/eventlib/httpc.py index e373a7d..4a8d93e 100644 --- a/eventlib/httpc.py +++ b/eventlib/httpc.py @@ -25,10 +25,10 @@ import os.path import os import time -import urlparse +import urllib.parse -url_parser = urlparse.urlparse +url_parser = urllib.parse.urlparse _old_HTTPConnection = httplib.HTTPConnection @@ -132,10 +132,10 @@ def request(self, method, fullpath, body='', headers=None): pass # don't complain if already deleted elif method == 'put': try: - f = file(self.path, 'w') + f = open(self.path, 'w') f.write(body) f.close() - except IOError, e: + except IOError as e: self.status = 500 self.raise_connection_error() elif method == 'get': @@ -159,7 +159,7 @@ def getheader(self, header): def read(self, howmuch=None): if self.method == 'get': try: - fl = file(self.path, 'r') + fl = open(self.path, 'r') if howmuch is None: return fl.read() else: @@ -214,7 +214,7 @@ def __init__(self, url, method, body='', headers=None, dumper=None, class _LocalParams(_Params): def __init__(self, params, **kwargs): self._delegate = params - for k, v in kwargs.iteritems(): + for k, v in kwargs.items(): setattr(self, k, v) def __getattr__(self, key): @@ -224,7 +224,7 @@ def __getattr__(self, key): def __reduce__(self): params = copy.copy(self._delegate) kwargs = copy.copy(self.__dict__) - assert(kwargs.has_key('_delegate')) + assert('_delegate' in kwargs) del kwargs['_delegate'] if hasattr(params,'aux'): del params.aux return (_LocalParams,(params,),kwargs) @@ -567,7 +567,7 @@ def request_(self, params, connection=None): body = make_safe_loader(self.loader(body)) except KeyboardInterrupt: raise - except Exception, e: + except Exception as e: raise UnparseableResponse(response.msg.get('content-type', '(unknown)'), self.loader, body, @@ -631,7 +631,7 @@ def doit(): while retried <= max_retries: try: return req() - except (Found, TemporaryRedirect, MovedPermanently, SeeOther), e: + except (Found, TemporaryRedirect, MovedPermanently, SeeOther) as e: if retried >= max_retries: raise retried += 1 diff --git a/eventlib/httpd.py b/eventlib/httpd.py index ae00149..59850ce 100644 --- a/eventlib/httpd.py +++ b/eventlib/httpd.py @@ -25,14 +25,14 @@ import socket import sys import time -import urllib +import urllib.request, urllib.parse, urllib.error import traceback -import BaseHTTPServer +import http.server try: - from cStringIO import StringIO + from io import StringIO except ImportError: - from StringIO import StringIO + from io import StringIO from eventlib import api from eventlib.pool import Pool @@ -47,7 +47,7 @@ class ErrorResponse(Exception): - _responses = BaseHTTPServer.BaseHTTPRequestHandler.responses + _responses = http.server.BaseHTTPRequestHandler.responses def __init__(self, code, reason_phrase=None, headers=None, body=None): Exception.__init__(self, reason_phrase) @@ -96,7 +96,7 @@ def response(self, code, reason_phrase=None, headers=None, body=None): self.protocol.set_response_code(self, code, reason_phrase) if headers is not None: try: - headers = headers.iteritems() + headers = iter(headers.items()) except AttributeError: pass for key, value in headers: @@ -115,7 +115,7 @@ def full_url(self): via = self.get_header('via', '') if via.strip(): - next_part = iter(via.split()).next + next_part = iter(via.split()).__next__ received_protocol = next_part() received_by = next_part() @@ -164,14 +164,14 @@ def begin_response(self, length="-"): response_lines = proto.generate_status_line() - if not self._outgoing_headers.has_key('connection'): + if 'connection' not in self._outgoing_headers: con = self.get_header('connection') if con is None and proto.request_version == 'HTTP/1.0': con = 'close' if con is not None: self.set_header('connection', con) - for key, value in self._outgoing_headers.items(): + for key, value in list(self._outgoing_headers.items()): key = '-'.join([x.capitalize() for x in key.split('-')]) response_lines.append("%s: %s" % (key, value)) @@ -184,7 +184,7 @@ def write(self, obj): """ if isinstance(obj, str): self._write_bytes(obj) - elif isinstance(obj, unicode): + elif isinstance(obj, str): # use utf8 encoding for now, *TODO support charset negotiation # Content-Type: text/html; charset=utf-8 ctype = self._outgoing_headers.get('content-type', 'text/html') @@ -199,7 +199,7 @@ def _write_bytes(self, data): Can be called just once. """ if self._request_started: - print "Request has already written a response:" + print("Request has already written a response:") traceback.print_stack() return @@ -218,7 +218,7 @@ def path(self): return self._path def path_segments(self): - return [urllib.unquote_plus(x) for x in self._path.split('/')[1:]] + return [urllib.parse.unquote_plus(x) for x in self._path.split('/')[1:]] def query(self): return self._query @@ -249,7 +249,7 @@ def get_query_pairs(self): value = '' else: key, value = query - self._split_query.append((urllib.unquote_plus(key), urllib.unquote_plus(value))) + self._split_query.append((urllib.parse.unquote_plus(key), urllib.parse.unquote_plus(value))) return self._split_query @@ -264,7 +264,7 @@ def get_queries_generator(self, name): def get_query(self, name, default=None): try: - return self.get_queries_generator(name).next() + return next(self.get_queries_generator(name)) except StopIteration: return default @@ -304,7 +304,7 @@ def get_outgoing_header(self, key): return self._outgoing_headers[key.lower()] def has_outgoing_header(self, key): - return self._outgoing_headers.has_key(key.lower()) + return key.lower() in self._outgoing_headers def socket(self): return self.protocol.rfile._sock @@ -323,7 +323,7 @@ def error(self, response=None, body=None, log_traceback=True): return try: self.site.adapt(body, self) - except Exception, e: + except Exception as e: traceback.print_exc(file=self.log) if not self.response_written(): self.write('Internal Server Error') @@ -411,7 +411,7 @@ def __repr__(self): class Timeout(RuntimeError): pass -class HttpProtocol(BaseHTTPServer.BaseHTTPRequestHandler): +class HttpProtocol(http.server.BaseHTTPRequestHandler): def __init__(self, request, client_address, server): self.rfile = self.wfile = request.makefile() self.is_secure = request.is_secure @@ -463,7 +463,7 @@ def handle(self): self.write_bad_request(414, 'Request-URI Too Long') self.close_connection = True continue - except socket.error, e: + except socket.error as e: if e[0] in CONNECTION_CLOSED: self.close_connection = True cancel.cancel() @@ -471,15 +471,15 @@ def handle(self): except Timeout: self.close_connection = True continue - except Exception, e: + except Exception as e: try: if e[0][0][0].startswith('SSL'): - print "SSL Error:", e[0][0] + print("SSL Error:", e[0][0]) self.close_connection = True cancel.cancel() continue - except Exception, f: - print "Exception in ssl test:",f + except Exception as f: + print("Exception in ssl test:",f) pass raise e cancel.cancel() @@ -494,14 +494,14 @@ def handle(self): request.set_header('Date', self.date_time_string()) try: timeout = int(request.get_header('keep-alive', timeout)) - except TypeError, ValueError: + except TypeError as ValueError: pass try: try: try: self.server.site.handle_request(request) - except ErrorResponse, err: + except ErrorResponse as err: request.response(code=err.code, reason_phrase=err.reason, headers=err.headers, @@ -521,14 +521,14 @@ def handle(self): except: pass - except socket.error, e: + except socket.error as e: # Broken pipe, connection reset by peer if e[0] in CONNECTION_CLOSED: #print "Remote host closed connection before response could be sent" pass else: raise - except Exception, e: + except Exception as e: self.server.log_message("Exception caught in HttpRequest.handle():\n") self.server.log_exception(*sys.exc_info()) if not request.response_written(): @@ -539,7 +539,7 @@ def handle(self): self.close() -class Server(BaseHTTPServer.HTTPServer): +class Server(http.server.HTTPServer): def __init__(self, socket, address, site, log, max_http_version=DEFAULT_MAX_HTTP_VERSION): self.socket = socket self.address = address diff --git a/eventlib/httpdate.py b/eventlib/httpdate.py index d530667..73fe2df 100644 --- a/eventlib/httpdate.py +++ b/eventlib/httpdate.py @@ -1,3 +1,3 @@ -from wsgi import format_date_time +from .wsgi import format_date_time import warnings warnings.warn("httpdate module is deprecated; its contents is moved to wsgi.py", DeprecationWarning, stacklevel=2) diff --git a/eventlib/hubs/hub.py b/eventlib/hubs/hub.py index d64592d..bbc5ffd 100644 --- a/eventlib/hubs/hub.py +++ b/eventlib/hubs/hub.py @@ -121,11 +121,11 @@ def switch(self): def squelch_exception(self, fileno, exc_info): traceback.print_exception(*exc_info) - print >>sys.stderr, "Removing descriptor: %r" % (fileno,) + print("Removing descriptor: %r" % (fileno,), file=sys.stderr) try: self.remove_descriptor(fileno) - except Exception, e: - print >>sys.stderr, "Exception while removing descriptor! %r" % (e,) + except Exception as e: + print("Exception while removing descriptor! %r" % (e,), file=sys.stderr) def wait(self, seconds=None): raise NotImplementedError("Implement this in a subclass") @@ -207,7 +207,7 @@ def remove_observer(self, observer): def squelch_observer_exception(self, observer, exc_info): traceback.print_exception(*exc_info) - print >>sys.stderr, "Removing observer: %r" % (observer,) + print("Removing observer: %r" % (observer,), file=sys.stderr) self.remove_observer(observer) def fire_observers(self, activity): @@ -221,7 +221,7 @@ def fire_observers(self, activity): def squelch_timer_exception(self, timer, exc_info): traceback.print_exception(*exc_info) - print >>sys.stderr, "Timer raised: %r" % (timer,) + print("Timer raised: %r" % (timer,), file=sys.stderr) def _add_absolute_timer(self, when, info): # the 0 placeholder makes it easy to bisect_right using (now, 1) @@ -276,7 +276,7 @@ def fire_timers(self, when): t = self.timers last = bisect.bisect_right(t, (when, 1)) i = 0 - for i in xrange(last): + for i in range(last): timer = t[i][2] try: try: diff --git a/eventlib/hubs/poll.py b/eventlib/hubs/poll.py index 830c6c9..3b474f1 100644 --- a/eventlib/hubs/poll.py +++ b/eventlib/hubs/poll.py @@ -74,7 +74,7 @@ def wait(self, seconds=None): return try: presult = self.poll.poll(seconds * 1000.0) - except select.error, e: + except select.error as e: if e.args[0] == errno.EINTR: return raise diff --git a/eventlib/hubs/selects.py b/eventlib/hubs/selects.py index 9683985..81b2c47 100644 --- a/eventlib/hubs/selects.py +++ b/eventlib/hubs/selects.py @@ -36,8 +36,8 @@ def wait(self, seconds=None): time.sleep(seconds) return try: - r, w, ig = select.select(readers.keys(), writers.keys(), [], seconds) - except select.error, e: + r, w, ig = select.select(list(readers.keys()), list(writers.keys()), [], seconds) + except select.error as e: if e.args[0] == errno.EINTR: return raise diff --git a/eventlib/hubs/twistedr.py b/eventlib/hubs/twistedr.py index a1507bb..a270344 100644 --- a/eventlib/hubs/twistedr.py +++ b/eventlib/hubs/twistedr.py @@ -54,7 +54,7 @@ def _set_cancelled(self, value): def callLater(DelayedCallClass, reactor, _seconds, _f, *args, **kw): # the same as original but creates fixed DelayedCall instance assert callable(_f), "%s is not callable" % _f - assert sys.maxint >= _seconds >= 0, \ + assert sys.maxsize >= _seconds >= 0, \ "%s is not greater than or equal to 0 seconds" % (_seconds,) tple = DelayedCallClass(reactor.seconds() + _seconds, _f, args, kw, reactor._cancelCallLater, @@ -275,7 +275,10 @@ def mainLoop(self, reactor): reactor.runUntilCurrent() t2 = reactor.timeout() t = reactor.running and t2 - reactor.doIteration(t) + try: + reactor.doIteration(t) + except NotImplementedError: + pass Hub = TwistedHub diff --git a/eventlib/pool.py b/eventlib/pool.py index f645052..8aa6514 100644 --- a/eventlib/pool.py +++ b/eventlib/pool.py @@ -217,7 +217,7 @@ def generate_results(self, function, iterable, qsize=None): # but if we launched no coroutines with that queue as the destination, # we could end up waiting a very long time. try: - index, args = tuples.next() + index, args = next(tuples) except StopIteration: return # From this point forward, 'args' is the current arguments tuple and @@ -259,7 +259,7 @@ def generate_results(self, function, iterable, qsize=None): # which to send() the result. self._execute(q, function, args, {}) # We've consumed that args tuple, advance to next. - index, args = tuples.next() + index, args = next(tuples) # Okay, we've filled up the pool again, yield a result -- which # will probably wait for a coroutine to complete. Although we do # have q.ready(), so we could iterate without waiting, we avoid diff --git a/eventlib/pools.py b/eventlib/pools.py index f87367f..da049ea 100644 --- a/eventlib/pools.py +++ b/eventlib/pools.py @@ -73,7 +73,7 @@ def __init__(self, min_size=0, max_size=4, order_as_stack=False): self.current_size = 0 self.channel = coros.queue(0) self.free_items = collections.deque() - for x in xrange(min_size): + for x in range(min_size): self.current_size += 1 self.free_items.append(self.create()) @@ -156,7 +156,7 @@ def fan(self, block, input_list): def _invoke(self, block, pool_item, input_item, index, queue): try: result = block(pool_item, input_item) - except Exception, e: + except Exception as e: self.put(pool_item) queue.send((index, e)) return @@ -195,7 +195,7 @@ def __init__(self, proto, netloc, use_proxy, min_size=0, max_size=4): Pool.__init__(self, min_size, max_size) def create(self): - import httpc + from . import httpc return httpc.make_connection(self.proto, self.netloc, self.use_proxy) def put(self, item): diff --git a/eventlib/proc.py b/eventlib/proc.py index b533f79..d6c4e36 100644 --- a/eventlib/proc.py +++ b/eventlib/proc.py @@ -84,7 +84,7 @@ 'LinkedKilled', 'ProcExit', 'waitall', - 'killall' + 'killall', 'Source', 'Proc', 'spawn', @@ -214,7 +214,7 @@ def killall(procs, *throw_args, **kwargs): throw_args = (ProcExit, ) wait = kwargs.pop('wait', False) if kwargs: - raise TypeError('Invalid keyword argument for proc.killall(): %s' % ', '.join(kwargs.keys())) + raise TypeError('Invalid keyword argument for proc.killall(): %s' % ', '.join(list(kwargs.keys()))) for g in procs: if not g.dead: api.get_hub().schedule_call_global(0, g.throw, *throw_args) @@ -408,7 +408,7 @@ def send(self, value): self._start_send() def _start_send(self): - api.get_hub().schedule_call_global(0, self._do_send, self._value_links.items(), self._value_links) + api.get_hub().schedule_call_global(0, self._do_send, list(self._value_links.items()), self._value_links) def send_exception(self, *throw_args): assert not self.ready(), "%s has been fired already" % self @@ -417,7 +417,7 @@ def send_exception(self, *throw_args): self._start_send_exception() def _start_send_exception(self): - api.get_hub().schedule_call_global(0, self._do_send, self._exception_links.items(), self._exception_links) + api.get_hub().schedule_call_global(0, self._do_send, list(self._exception_links.items()), self._exception_links) def _do_send(self, links, consult): while links: @@ -532,7 +532,7 @@ def __repr__(self): klass = type(self).__name__ return '<%s %s>' % (klass, ' '.join(self._repr_helper())) - def __nonzero__(self): + def __bool__(self): if self.ready(): # with current _run this does not makes any difference # still, let keep it there @@ -569,7 +569,7 @@ def _run(self, function, args, kwargs): """ try: result = function(*args, **kwargs) - except api.GreenletExit, e: + except api.GreenletExit as e: self.send_exception(e) raise except: @@ -630,7 +630,7 @@ def trap_errors(errors, func, *args, **kwargs): """DEPRECATED in favor of wrap_errors""" try: return func(*args, **kwargs) - except errors, ex: + except errors as ex: return ex @@ -665,7 +665,7 @@ def __init__(self, errors, func): def __call__(self, *args, **kwargs): try: return self.func(*args, **kwargs) - except self.errors, ex: + except self.errors as ex: return ex def __str__(self): diff --git a/eventlib/processes.py b/eventlib/processes.py index 9fab2df..bdc1349 100644 --- a/eventlib/processes.py +++ b/eventlib/processes.py @@ -52,14 +52,14 @@ def wait_on_children(): event = CHILD_EVENTS.pop(child_pobj, None) if event: event.send(code) - except OSError, e: + except OSError as e: if e[0] == errno.ECHILD: - print "already dead" + print("already dead") # Already dead; signal, but assume success event = CHILD_EVENTS.pop(child_pobj, None) event.send(0) else: - print "raising" + print("raising") raise e CHILD_POBJS = unclosed_pobjs @@ -139,7 +139,7 @@ def write(self, stuff): try: written = self.child_stdin.write(stuff) self.child_stdin.flush() - except ValueError, e: + except ValueError as e: ## File was closed assert str(e) == 'I/O operation on closed file' if written == 0: diff --git a/eventlib/saranwrap.py b/eventlib/saranwrap.py index 4b9cb2d..071d948 100644 --- a/eventlib/saranwrap.py +++ b/eventlib/saranwrap.py @@ -85,7 +85,7 @@ request class is basically an action and a map of parameters' """ -from cPickle import dumps, loads +from pickle import dumps, loads import os import struct import sys @@ -185,9 +185,9 @@ def _read_response(id, attribute, input, cp): """@brief local helper method to read respones from the rpc server.""" try: str = _read_lp_hunk(input) - _prnt(`str`) + _prnt(repr(str)) response = loads(str) - except (AttributeError, DeadProcess), e: + except (AttributeError, DeadProcess) as e: raise UnrecoverableError(e) _prnt("response: %s" % response) if response[0] == 'value': @@ -224,7 +224,7 @@ def _is_local(attribute): def _prnt(message): global _g_debug_mode if _g_debug_mode: - print message + print(message) _g_logfile = None def _log(message): @@ -395,7 +395,7 @@ def __str__(self): # tack anything on to the return value here because str values are used as data. return self.__str__() - def __nonzero__(self): + def __bool__(self): # bool(obj) is another method that skips __getattribute__. There's no good way to just pass # the method on, so we use a special message. my_cp = self.__local_dict['_cp'] @@ -493,7 +493,7 @@ def handle_status(self, obj, req): def handle_getattr(self, obj, req): try: return getattr(obj, req['attribute']) - except AttributeError, e: + except AttributeError as e: if hasattr(obj, "__getitem__"): return obj[req['attribute']] else: @@ -503,7 +503,7 @@ def handle_getattr(self, obj, req): def handle_setattr(self, obj, req): try: return setattr(obj, req['attribute'], req['value']) - except AttributeError, e: + except AttributeError as e: if hasattr(obj, "__setitem__"): return obj.__setitem__(req['attribute'], req['value']) else: @@ -521,7 +521,7 @@ def handle_eq(self, obj, req): rhs = None try: rhs = self._objects[req['rhs']] - except KeyError, e: + except KeyError as e: return False return (obj == rhs) @@ -529,7 +529,7 @@ def handle_call(self, obj, req): #_log("calling %s " % (req['name'])) try: fn = getattr(obj, req['name']) - except AttributeError, e: + except AttributeError as e: if hasattr(obj, "__setitem__"): fn = obj[req['name']] else: @@ -581,7 +581,7 @@ def loop(self): id = int(id) obj = self._objects[id] #_log("id, object: %d %s" % (id, obj)) - except Exception, e: + except Exception as e: #_log("Exception %s" % str(e)) pass if obj is None or id is None: @@ -595,7 +595,7 @@ def loop(self): try: handler = getattr(self, handler_name) except AttributeError: - raise BadRequest, request.action() + raise BadRequest(request.action()) response = handler(obj, request) @@ -615,9 +615,9 @@ def loop(self): #_log("objects: %s" % str(self._objects)) self.respond(['object', self._next_id]) self._next_id += 1 - except SystemExit, e: + except SystemExit as e: raise e - except Exception, e: + except Exception as e: self.write_exception(e) except: self.write_exception(sys.exc_info()[0]) @@ -628,13 +628,13 @@ def is_value(self, value): @param value The value to test. @return Returns true if value is a simple serializeable set of data. """ - return type(value) in (str,unicode,int,float,long,bool,type(None)) + return type(value) in (str,str,int,float,int,bool,type(None)) def respond(self, body): _log("responding with: %s" % body) #_log("objects: %s" % self._objects) s = dumps(body) - _log(`s`) + _log(repr(s)) str_ = _write_lp_hunk(self._out, s) def write_exception(self, e): @@ -665,12 +665,12 @@ def raise_standard_error(): # test function to make sure print doesn't break the wrapper def print_string(str): - print str + print(str) # test function to make sure printing on stdout doesn't break the # wrapper def err_string(str): - print >>sys.stderr, str + print(str, file=sys.stderr) def main(): import optparse diff --git a/eventlib/support/greenlets.py b/eventlib/support/greenlets.py index ffe4aae..23ae89a 100644 --- a/eventlib/support/greenlets.py +++ b/eventlib/support/greenlets.py @@ -4,7 +4,7 @@ getcurrent = greenlet.getcurrent GreenletExit = greenlet.GreenletExit greenlet = greenlet.greenlet -except ImportError, e: +except ImportError as e: try: from py.magic import greenlet getcurrent = greenlet.getcurrent @@ -17,5 +17,5 @@ except ImportError: try: from support.stacklesss import greenlet, getcurrent, GreenletExit - except ImportError, e: + except ImportError as e: raise ImportError("Unable to find an implementation of greenlet.") diff --git a/eventlib/timer.py b/eventlib/timer.py index 67588cd..db6851b 100644 --- a/eventlib/timer.py +++ b/eventlib/timer.py @@ -43,8 +43,8 @@ def __init__(self, seconds, cb, *args, **kw): self.tpl = cb, args, kw self.called = False if _g_debug: - import traceback, cStringIO - self.traceback = cStringIO.StringIO() + import traceback, io + self.traceback = io.StringIO() traceback.print_stack(file=self.traceback) @property diff --git a/eventlib/tpool.py b/eventlib/tpool.py index fcf396f..98bcd76 100644 --- a/eventlib/tpool.py +++ b/eventlib/tpool.py @@ -16,14 +16,14 @@ import os import threading -from Queue import Empty, Queue +from queue import Empty, Queue from eventlib import api, coros, greenio QUIET=False _rpipe, _wpipe = os.pipe() -_rfile = os.fdopen(_rpipe,"r",0) +_rfile = os.fdopen(_rpipe,"rb",0) ## Work whether or not wrap_pipe_with_coroutine_pipe was called if not isinstance(_rfile, greenio.GreenPipe): _rfile = greenio.GreenPipe(_rfile) @@ -31,7 +31,7 @@ def _signal_t2e(): from eventlib import util - nwritten = util.__original_write__(_wpipe, ' ') + nwritten = util.__original_write__(_wpipe, b' ') _reqq = Queue(maxsize=-1) _rspq = Queue(maxsize=-1) @@ -70,7 +70,7 @@ def tworker(): rv = meth(*args,**kwargs) except SYS_EXCS: raise - except Exception,exn: + except Exception as exn: import sys (a,b,tb) = sys.exc_info() rv = (exn,a,b,tb) @@ -159,7 +159,7 @@ def __str__(self): return self._obj.__str__() def __len__(self): return len(self._obj) - def __nonzero__(self): + def __bool__(self): return bool(self._obj) @@ -181,6 +181,6 @@ def setup(): def killall(): for i in _threads: _reqq.put(None) - for thr in _threads.values(): + for thr in list(_threads.values()): thr.join() diff --git a/eventlib/twistedutil/__init__.py b/eventlib/twistedutil/__init__.py index 94f73c8..c4ba099 100644 --- a/eventlib/twistedutil/__init__.py +++ b/eventlib/twistedutil/__init__.py @@ -76,23 +76,23 @@ def callInGreenThread(func, *args, **kwargs): sys.exit('Supply number of test as an argument, 0, 1, 2 or 3') from twisted.internet import reactor def test(): - print block_on(reactor.resolver.getHostByName('www.google.com')) - print block_on(reactor.resolver.getHostByName('###')) + print(block_on(reactor.resolver.getHostByName('www.google.com'))) + print(block_on(reactor.resolver.getHostByName('###'))) if num==0: test() elif num==1: spawn(test) from eventlib.api import sleep - print 'sleeping..' + print('sleeping..') sleep(5) - print 'done sleeping..' + print('done sleeping..') elif num==2: from eventlib.twistedutil import join_reactor spawn(test) reactor.run() elif num==3: from eventlib.twistedutil import join_reactor - print "fails because it's impossible to use block_on from the mainloop" + print("fails because it's impossible to use block_on from the mainloop") reactor.callLater(0, test) reactor.run() diff --git a/eventlib/twistedutil/protocol.py b/eventlib/twistedutil/protocol.py index 75c34bc..61abe1b 100644 --- a/eventlib/twistedutil/protocol.py +++ b/eventlib/twistedutil/protocol.py @@ -29,7 +29,7 @@ from eventlib import proc from eventlib.api import getcurrent -from eventlib.coros import queue, event +from eventlib.coros import queue, event, NOT_USED class ValueQueue(queue): @@ -126,9 +126,11 @@ def _wait(self): self.pauseProducing() def write(self, data, wait=True): + if not isinstance(data, bytes): + data = data.encode() if self._disconnected_event.ready(): raise self._disconnected_event.wait() - if wait: + if wait and self._write_event._result is not NOT_USED: self._write_event.reset() self.transport.write(data) self._write_event.wait() @@ -230,7 +232,7 @@ def read(self): def __iter__(self): return self - def next(self): + def __next__(self): result = self.recv() if not result: raise StopIteration @@ -240,7 +242,7 @@ def next(self): class GreenTransport(GreenTransportBase): protocol_class = Protocol - _buffer = '' + _buffer = b'' _error = None def read(self, size=-1): @@ -257,7 +259,7 @@ def read(self, size=-1): if size>=0: result, self._buffer = self._buffer[:size], self._buffer[size:] else: - result, self._buffer = self._buffer, '' + result, self._buffer = self._buffer, b'' if not result and self._disconnected_event.has_exception(): try: self._disconnected_event.wait() @@ -282,7 +284,7 @@ def recv(self, buflen=None): finally: self.pauseProducing() if buflen is None: - result, self._buffer = self._buffer, '' + result, self._buffer = self._buffer, b'' else: result, self._buffer = self._buffer[:buflen], self._buffer[buflen:] if not result and self._disconnected_event.has_exception(): @@ -297,7 +299,7 @@ def recv(self, buflen=None): def __iter__(self): return self - def next(self): + def __next__(self): res = self.recv() if not res: raise StopIteration diff --git a/eventlib/twistedutil/protocols/basic.py b/eventlib/twistedutil/protocols/basic.py index d4932c9..39d16be 100644 --- a/eventlib/twistedutil/protocols/basic.py +++ b/eventlib/twistedutil/protocols/basic.py @@ -54,7 +54,7 @@ def sendline(self, line): def __iter__(self): return self - def next(self): + def __next__(self): try: return self.readline() except ConnectionDone: diff --git a/eventlib/util.py b/eventlib/util.py index da3408e..d230ad3 100644 --- a/eventlib/util.py +++ b/eventlib/util.py @@ -25,6 +25,7 @@ import socket import errno import sys +import ssl def g_log(*args): @@ -37,11 +38,11 @@ def g_log(*args): else: g_id = id(greenlet.getcurrent()) if g_id < 0: - g_id += 1 + ((sys.maxint + 1) << 1) + g_id += 1 + ((sys.maxsize + 1) << 1) ident = '%08X' % (g_id,) else: ident = 'greenlet-%d' % (g_id,) - print >>sys.stderr, '[%s] %s' % (ident, ' '.join(map(str, args))) + print('[%s] %s' % (ident, ' '.join(map(str, args))), file=sys.stderr) __original_socket__ = socket.socket @@ -77,7 +78,7 @@ def new_read(fd, *args, **kw): from eventlib import api try: api.trampoline(fd, read=True) - except socket.error, e: + except socket.error as e: if e[0] == errno.EPIPE: return '' else: @@ -120,6 +121,13 @@ def new_waitpid(pid, options): except ImportError: pass +def wrap_ssl(sock, certificate=None, private_key=None): + return ssl.wrap_socket(sock, + keyfile=private_key, certfile=certificate, + server_side=False, cert_reqs=ssl.CERT_NONE, + ssl_version=ssl.PROTOCOL_SSLv23, ca_certs=None, + do_handshake_on_connect=False, + suppress_ragged_eofs=True) def wrap_threading_local_with_coro_local(): """monkey patch threading.local with something that is diff --git a/eventlib/wsgi.py b/eventlib/wsgi.py index 0d01cec..108cd3c 100644 --- a/eventlib/wsgi.py +++ b/eventlib/wsgi.py @@ -25,6 +25,7 @@ import sys import time import traceback +import urllib.parse as urllib_parse from eventlib.green import urllib from eventlib.green import socket from eventlib.green import BaseHTTPServer @@ -117,7 +118,7 @@ def handle_one_request(self): "HTTP/1.0 414 Request URI Too Long\r\nConnection: close\r\nContent-length: 0\r\n\r\n") self.close_connection = 1 return - except socket.error, e: + except socket.error as e: if e[0] != errno.EBADF: raise self.raw_requestline = '' @@ -135,7 +136,7 @@ def handle_one_request(self): self.server.outstanding_requests += 1 try: self.handle_one_response() - except socket.error, e: + except socket.error as e: # Broken pipe, connection reset by peer if e[0] in (32, 54): pass @@ -193,7 +194,7 @@ def write(data, _writelines=wfile.writelines): _writelines(towrite) length[0] = length[0] + sum(map(len, towrite)) except UnicodeEncodeError: - print "Encountered unicode while attempting to write wsgi response: ", [x for x in towrite if isinstance(x, unicode)] + print("Encountered unicode while attempting to write wsgi response: ", [x for x in towrite if isinstance(x, str)]) traceback.print_exc() _writelines( ["HTTP/1.0 500 Internal Server Error\r\n", @@ -209,7 +210,7 @@ def start_response(status, response_headers, exc_info=None): try: if headers_sent: # Re-raise original exception if headers sent - raise exc_info[0], exc_info[1], exc_info[2] + raise exc_info[0](exc_info[1]).with_traceback(exc_info[2]) finally: # Avoid dangling circular ref exc_info = None @@ -222,9 +223,9 @@ def start_response(status, response_headers, exc_info=None): try: result = self.application(self.environ, start_response) - except Exception, e: + except Exception as e: exc = ''.join(traceback.format_exception(*sys.exc_info())) - print exc + print(exc) if not headers_set: start_response("500 Internal Server Error", [('Content-type', 'text/plain')]) write(exc) @@ -244,9 +245,9 @@ def start_response(status, response_headers, exc_info=None): if use_chunked and sum(map(len, towrite)) > self.minimum_chunk_size: write(''.join(towrite)) del towrite[:] - except Exception, e: + except Exception as e: exc = traceback.format_exc() - print exc + print(exc) if not headers_set: start_response("500 Internal Server Error", [('Content-type', 'text/plain')]) write(exc) @@ -258,7 +259,7 @@ def start_response(status, response_headers, exc_info=None): write('') if use_chunked: wfile.write('0\r\n\r\n') - except Exception, e: + except Exception as e: traceback.print_exc() finally: if hasattr(result, 'close'): @@ -285,17 +286,17 @@ def get_environ(self): path, query = self.path.split('?', 1) else: path, query = self.path, '' - env['PATH_INFO'] = urllib.unquote(path) + env['PATH_INFO'] = urllib_parse.unquote(path) env['QUERY_STRING'] = query - if self.headers.typeheader is None: - env['CONTENT_TYPE'] = self.headers.type + if self.headers.get('content-type') is None: + env['CONTENT_TYPE'] = self.headers.get_content_type() else: - env['CONTENT_TYPE'] = self.headers.typeheader - - length = self.headers.getheader('content-length') + env['CONTENT_TYPE'] = self.headers['content-type'] + length = self.headers.get('content-length') if length: env['CONTENT_LENGTH'] = length + env['SERVER_PROTOCOL'] = 'HTTP/1.0' host, port = self.request.getsockname() @@ -304,8 +305,8 @@ def get_environ(self): env['REMOTE_ADDR'] = self.client_address[0] env['GATEWAY_INTERFACE'] = 'CGI/1.1' - for h in self.headers.headers: - k, v = h.split(':', 1) + for k in self.headers: + v = self.headers.get(k) k = k.replace('-', '_').upper() v = v.strip() if k in env: @@ -363,7 +364,8 @@ def get_environ(self): d.update(self.environ) return d - def process_request(self, (socket, address)): + def process_request(self, req): + (socket, address) = req proto = self.protocol(socket, address, self) proto.handle() @@ -390,23 +392,23 @@ def server(sock, site, log=None, environ=None, max_size=None, max_http_version=D if port == ':80': port = '' - print "(%s) wsgi starting up on %s://%s%s/" % (os.getpid(), scheme, host, port) + print("(%s) wsgi starting up on %s://%s%s/" % (os.getpid(), scheme, host, port)) while True: try: try: client_socket = sock.accept() - except socket.error, e: + except socket.error as e: if e[0] != errno.EPIPE and e[0] != errno.EBADF: raise pool.execute_async(serv.process_request, client_socket) except KeyboardInterrupt: api.get_hub().remove_descriptor(sock.fileno()) - print "wsgi exiting" + print("wsgi exiting") break finally: try: sock.close() - except socket.error, e: + except socket.error as e: if e[0] != errno.EPIPE: raise diff --git a/examples/connect.py b/examples/connect.py index 72e45e5..b53bc98 100644 --- a/examples/connect.py +++ b/examples/connect.py @@ -34,13 +34,13 @@ def geturl(url): c = socket.socket() ip = socket.gethostbyname(url) c.connect((ip, 80)) - print '%s connected' % url + print('%s connected' % url) c.send('GET /\r\n\r\n') return c.recv(1024) urls = ['www.google.com', 'www.yandex.ru', 'www.python.org', 'ag-projects.com', 'sylkserver.com'] jobs = [proc.spawn(geturl, x) for x in urls] -print 'spawned %s jobs' % len(jobs) +print('spawned %s jobs' % len(jobs)) # collect the results from workers results = proc.waitall(jobs) @@ -48,5 +48,5 @@ def geturl(url): # unless trap_errors argument specifies otherwise for url, result in zip(urls, results): - print '%s: %s' % (url, repr(result)[:50]) + print('%s: %s' % (url, repr(result)[:50])) diff --git a/examples/echoserver.py b/examples/echoserver.py old mode 100755 new mode 100644 index 9bbbb0c..4daa6c4 --- a/examples/echoserver.py +++ b/examples/echoserver.py @@ -1,4 +1,4 @@ -#!/usr/bin/python2 +#!/usr/bin/python3 """\ @file echoserver.py @@ -35,16 +35,16 @@ from eventlib import api def handle_socket(reader, writer): - print "client connected" + print ("client connected") while True: # pass through every non-eof line x = reader.readline() if not x: break writer.write(x) - print "echoed", x - print "client disconnected" + print(("echoed", x)) + print ("client disconnected") -print "server socket listening on port 6000" +print ("server socket listening on port 6000") server = api.tcp_listener(('0.0.0.0', 6000)) while True: try: diff --git a/examples/twisted_client.py b/examples/twisted_client.py index eca9521..e0c3886 100644 --- a/examples/twisted_client.py +++ b/examples/twisted_client.py @@ -9,18 +9,22 @@ from eventlib.twistedutil.protocols.basic import LineOnlyReceiverTransport from twisted.internet import reactor +print("\n\nRead from TCP connection\n\n") + # read from TCP connection conn = GreenClientCreator(reactor).connectTCP('www.google.com', 80) -conn.write('GET / HTTP/1.0\r\n\r\n') +conn.write('GET /not_found HTTP/1.0\r\n\r\n') conn.loseWriteConnection() -print conn.read() +print(conn.read().decode('utf-8')) + +print("\n\nRead from SSL connection line by line\n\n") # read from SSL connection line by line -conn = GreenClientCreator(reactor, LineOnlyReceiverTransport).connectSSL('sf.net', 443, ssl.ClientContextFactory()) -conn.write('GET / HTTP/1.0\r\n\r\n') +conn = GreenClientCreator(reactor, LineOnlyReceiverTransport).connectSSL('ssltest.com', 443, ssl.ClientContextFactory()) +conn.write('GET /not_found HTTP/1.0\r\n\r\n') try: for num, line in enumerate(conn): - print '%3s %r' % (num, line) -except ConnectionClosed, ex: - print ex + print('%3s %r' % (num, line)) +except ConnectionClosed as ex: + print(ex) diff --git a/examples/twisted_http_proxy.py b/examples/twisted_http_proxy.py index 20dae75..3bfa012 100644 --- a/examples/twisted_http_proxy.py +++ b/examples/twisted_http_proxy.py @@ -69,7 +69,7 @@ def http_request(method, host, path, headers): conn.request(method, path, headers=headers) response = conn.getresponse() body = response.read() - print method, host, path, response.status, response.reason, len(body) + print(method, host, path, response.status, response.reason, len(body)) return format_response(response, body) def format_response(response, body): @@ -85,6 +85,6 @@ def format_response(response, body): class MyFactory(Factory): protocol = LineOnlyReceiver -print __doc__ +print(__doc__) reactor.listenTCP(8888, MyFactory()) reactor.run() diff --git a/examples/twisted_portforward.py b/examples/twisted_portforward.py old mode 100755 new mode 100644 index 20c19be..3cfde3e --- a/examples/twisted_portforward.py +++ b/examples/twisted_portforward.py @@ -1,4 +1,4 @@ -#!/usr/bin/python2 +#!/usr/bin/python3 # Copyright (c) 2008-2009 AG Projects # Author: Denis Bilenko @@ -35,19 +35,19 @@ def forward(source, dest): x = source.recv() if not x: break - print 'forwarding %s bytes' % len(x) + print('forwarding %s bytes' % len(x)) dest.write(x) finally: dest.loseConnection() def handler(local): client = str(local.getHost()) - print 'accepted connection from %s' % client + print('accepted connection from %s' % client) remote = GreenClientCreator(reactor, UnbufferedTransport).connectTCP(remote_host, remote_port) a = proc.spawn(forward, remote, local) b = proc.spawn(forward, local, remote) proc.waitall([a, b], trap_errors=True) - print 'closed connection to %s' % client + print('closed connection to %s' % client) try: local_port, remote_host, remote_port = sys.argv[1:] diff --git a/examples/twisted_server.py b/examples/twisted_server.py index 3e2890e..1dbaa62 100644 --- a/examples/twisted_server.py +++ b/examples/twisted_server.py @@ -37,25 +37,25 @@ def __init__(self): def handler(self, conn): peer = conn.getPeer() - print 'new connection from %s' % (peer, ) + print('new connection from %s' % (peer, )) conn.write("Welcome! There're %s participants already\n" % (len(self.participants))) self.participants.append(conn) try: for line in conn: if line: - print 'received from %s: %s' % (peer, line) + print('received from %s: %s' % (peer, line)) for buddy in self.participants: if buddy is not conn: buddy.sendline('from %s: %s' % (peer, line)) - except Exception, ex: - print peer, ex + except Exception as ex: + print(peer, ex) else: - print peer, 'connection done' + print(peer, 'connection done') finally: conn.loseConnection() self.participants.remove(conn) -print __doc__ +print(__doc__) chat = Chat() from twisted.internet import reactor reactor.listenTCP(8007, SpawnFactory(chat.handler, LineOnlyReceiverTransport)) diff --git a/examples/twisted_srvconnector.py b/examples/twisted_srvconnector.py index cc9b015..d24ceab 100644 --- a/examples/twisted_srvconnector.py +++ b/examples/twisted_srvconnector.py @@ -30,7 +30,7 @@ class NoisySRVConnector(SRVConnector): def pickServer(self): host, port = SRVConnector.pickServer(self) - print 'Resolved _%s._%s.%s --> %s:%s' % (self.service, self.protocol, self.domain, host, port) + print('Resolved _%s._%s.%s --> %s:%s' % (self.service, self.protocol, self.domain, host, port)) return host, port cred = X509Credentials(None, None) @@ -46,10 +46,10 @@ def pickServer(self): -------49fh$ """.replace('\n', '\r\n') -print 'Sending:\n%s' % request +print('Sending:\n%s' % request) conn.write(request) -print 'Received:' +print('Received:') for x in conn: - print repr(x) + print(repr(x)) if '-------' in x: break diff --git a/examples/twisted_xcap_proxy.py b/examples/twisted_xcap_proxy.py index 7271384..50bf253 100644 --- a/examples/twisted_xcap_proxy.py +++ b/examples/twisted_xcap_proxy.py @@ -10,7 +10,7 @@ class LineOnlyReceiver(basic.LineOnlyReceiver): def lineReceived(self, line): - print 'received: %r' % line + print('received: %r' % line) if not line: return app, context, node = (line + ' ').split(' ', 3) diff --git a/greentest/api_test.py b/greentest/api_test.py index 6078371..73e70d9 100644 --- a/greentest/api_test.py +++ b/greentest/api_test.py @@ -73,8 +73,7 @@ def accept_once(listenfd): client = api.connect_tcp(('127.0.0.1', server.getsockname()[1])) fd = client.makeGreenFile() client.close() - assert fd.readline() == 'hello\n' - + assert fd.readline() == b'hello\n' assert fd.read() == '' fd.close() @@ -83,6 +82,7 @@ def accept_once(listenfd): def test_connect_ssl(self): def accept_once(listenfd): try: + listenfd.do_handshake_on_connect=False conn, addr = listenfd.accept() fl = conn.makeGreenFile('w') fl.write('hello\r\n') @@ -97,10 +97,10 @@ def accept_once(listenfd): api.spawn(accept_once, server) client = util.wrap_ssl( - api.connect_tcp(('127.0.0.1', server.getsockname()[1]))) - client = client.makeGreenFile() + api.connect_tcp(('127.0.0.1', server.getsockname()[1])), self.certificate_file, self.private_key_file ) + #client = client.makeGreenFile() - assert client.readline() == 'hello\r\n' + #assert client.readline() == b'hello\r\n' assert client.read() == '' client.close() @@ -109,7 +109,8 @@ def test_server(self): server = api.tcp_listener(('0.0.0.0', 0)) bound_port = server.getsockname()[1] - def accept_twice((conn, addr)): + def accept_twice(client): + (conn, addr) = client connected.append(True) conn.close() if len(connected) == 2: @@ -145,7 +146,8 @@ def test_timeout_cancel(self): server = api.tcp_listener(('0.0.0.0', 0)) bound_port = server.getsockname()[1] - def client_connected((conn, addr)): + def client_connected(server): + (conn, addr) = server conn.close() def go(): @@ -179,7 +181,7 @@ def test_explicit_hub(self): def test_named(self): named_foo = api.named('api_test.Foo') - self.assertEquals( + self.assertEqual( named_foo.__name__, "Foo") @@ -191,9 +193,9 @@ def test_timeout_and_final_write(self): # This test verifies that a write on a socket that we've # stopped listening for doesn't result in an incorrect switch rpipe, wpipe = os.pipe() - rfile = os.fdopen(rpipe,"r",0) + rfile = os.fdopen(rpipe,"rb",1) wrap_rfile = greenio.GreenPipe(rfile) - wfile = os.fdopen(wpipe,"w",0) + wfile = os.fdopen(wpipe,"wb",1) wrap_wfile = greenio.GreenPipe(wfile) def sender(evt): @@ -214,7 +216,7 @@ def sender(evt): pass result = evt.wait() - self.assertEquals(result, 'sent via event') + self.assertEqual(result, 'sent via event') class Foo(object): diff --git a/greentest/coros_test.py b/greentest/coros_test.py index a43b5f7..49960a1 100644 --- a/greentest/coros_test.py +++ b/greentest/coros_test.py @@ -144,7 +144,8 @@ def test_sleeping_during_received(self): # yields, eventually all messages are delivered msgs = [] waiters = [] - def received( (message, evt) ): + def received(rcvd): + (message, evt) = rcvd api.sleep(0) msgs.append(message) evt.send() @@ -168,7 +169,8 @@ def received( (message, evt) ): def test_raising_received(self): msgs = [] - def received( (message, evt) ): + def received(rcvd): + (message, evt) = rcvd evt.send() if message == 'fail': raise RuntimeError() @@ -188,7 +190,8 @@ def received( (message, evt) ): def test_multiple(self): self.actor = IncrActor(concurrency=2) total = [0] - def received( (func, ev, value) ): + def received(rcvd): + (func, ev, value) = rcvd func() total[0] += value ev.send() diff --git a/greentest/db_pool_test.py b/greentest/db_pool_test.py index 1bb06d3..51d3968 100755 --- a/greentest/db_pool_test.py +++ b/greentest/db_pool_test.py @@ -1,4 +1,4 @@ -#!/usr/bin/python2 +#!/usr/bin/python3 # @file test_mysql_pool.py # @brief Test cases for mysql_pool @@ -91,10 +91,10 @@ def assert_cursor_works(self, cursor): # TODO: this is pretty mysql-specific cursor.execute("show full processlist") rows = cursor.fetchall() - self.assert_(rows) + self.assertTrue(rows) def test_connecting(self): - self.assert_(self.connection is not None) + self.assertTrue(self.connection is not None) def test_create_cursor(self): cursor = self.connection.cursor() @@ -109,44 +109,44 @@ def test_run_bad_query(self): cursor = self.connection.cursor() try: cursor.execute("garbage blah blah") - self.assert_(False) + self.assertTrue(False) except AssertionError: raise - except Exception, e: + except Exception as e: pass cursor.close() def test_put_none(self): # the pool is of size 1, and its only connection is out - self.assert_(self.pool.free() == 0) + self.assertTrue(self.pool.free() == 0) self.pool.put(None) # ha ha we fooled it into thinking that we had a dead process - self.assert_(self.pool.free() == 1) + self.assertTrue(self.pool.free() == 1) conn2 = self.pool.get() - self.assert_(conn2 is not None) - self.assert_(conn2.cursor) + self.assertTrue(conn2 is not None) + self.assertTrue(conn2.cursor) del conn2 def test_close_does_a_put(self): - self.assert_(self.pool.free() == 0) + self.assertTrue(self.pool.free() == 0) self.connection.close() - self.assert_(self.pool.free() == 1) + self.assertTrue(self.pool.free() == 1) self.assertRaises(AttributeError, self.connection.cursor) def test_deletion_does_a_put(self): - self.assert_(self.pool.free() == 0) + self.assertTrue(self.pool.free() == 0) self.connection = None - self.assert_(self.pool.free() == 1) + self.assertTrue(self.pool.free() == 1) def test_put_doesnt_double_wrap(self): self.pool.put(self.connection) conn = self.pool.get() - self.assert_(not isinstance(conn._base, db_pool.PooledConnectionWrapper)) + self.assertTrue(not isinstance(conn._base, db_pool.PooledConnectionWrapper)) def test_bool(self): - self.assert_(self.connection) + self.assertTrue(self.connection) self.connection.close() - self.assert_(not self.connection) + self.assertTrue(not self.connection) def fill_test_table(self, conn): curs = conn.cursor() @@ -265,23 +265,23 @@ def test_clear(self): self.assertEqual(len(self.pool.free_items), 0) def test_unwrap_connection(self): - self.assert_(isinstance(self.connection, + self.assertTrue(isinstance(self.connection, db_pool.GenericConnectionWrapper)) conn = self.pool._unwrap_connection(self.connection) - self.assert_(not isinstance(conn, db_pool.GenericConnectionWrapper)) + self.assertTrue(not isinstance(conn, db_pool.GenericConnectionWrapper)) - self.assertEquals(None, self.pool._unwrap_connection(None)) - self.assertEquals(None, self.pool._unwrap_connection(1)) + self.assertEqual(None, self.pool._unwrap_connection(None)) + self.assertEqual(None, self.pool._unwrap_connection(1)) # testing duck typing here -- as long as the connection has a # _base attribute, it should be unwrappable x = Mock() x._base = 'hi' - self.assertEquals('hi', self.pool._unwrap_connection(x)) + self.assertEqual('hi', self.pool._unwrap_connection(x)) def test_safe_close(self): self.pool._safe_close(self.connection, quiet=True) - self.assertEquals(len(self.pool.free_items), 1) + self.assertEqual(len(self.pool.free_items), 1) self.pool._safe_close(None) self.pool._safe_close(1) @@ -303,32 +303,32 @@ def test_zero_max_idle(self): self.pool = self.create_pool(max_size=2, max_idle=0) self.connection = self.pool.get() self.connection.close() - self.assertEquals(len(self.pool.free_items), 0) + self.assertEqual(len(self.pool.free_items), 0) def test_zero_max_age(self): self.pool = self.create_pool(max_size=2, max_age=0) self.connection = self.pool.get() self.connection.close() - self.assertEquals(len(self.pool.free_items), 0) + self.assertEqual(len(self.pool.free_items), 0) def dont_test_max_idle(self): # This test is timing-sensitive. Rename the function without the "dont" to run it, but beware that it could fail or take a while. self.pool = self.create_pool(max_size=2, max_idle=0.02) self.connection = self.pool.get() self.connection.close() - self.assertEquals(len(self.pool.free_items), 1) + self.assertEqual(len(self.pool.free_items), 1) api.sleep(0.01) # not long enough to trigger the idle timeout - self.assertEquals(len(self.pool.free_items), 1) + self.assertEqual(len(self.pool.free_items), 1) self.connection = self.pool.get() self.connection.close() - self.assertEquals(len(self.pool.free_items), 1) + self.assertEqual(len(self.pool.free_items), 1) api.sleep(0.01) # idle timeout should have fired but done nothing - self.assertEquals(len(self.pool.free_items), 1) + self.assertEqual(len(self.pool.free_items), 1) self.connection = self.pool.get() self.connection.close() - self.assertEquals(len(self.pool.free_items), 1) + self.assertEqual(len(self.pool.free_items), 1) api.sleep(0.03) # long enough to trigger idle timeout for real - self.assertEquals(len(self.pool.free_items), 0) + self.assertEqual(len(self.pool.free_items), 0) def dont_test_max_idle_many(self): # This test is timing-sensitive. Rename the function without the "dont" to run it, but beware that it could fail or take a while. @@ -336,38 +336,38 @@ def dont_test_max_idle_many(self): self.connection, conn2 = self.pool.get(), self.pool.get() self.connection.close() api.sleep(0.01) - self.assertEquals(len(self.pool.free_items), 1) + self.assertEqual(len(self.pool.free_items), 1) conn2.close() - self.assertEquals(len(self.pool.free_items), 2) + self.assertEqual(len(self.pool.free_items), 2) api.sleep(0.02) # trigger cleanup of conn1 but not conn2 - self.assertEquals(len(self.pool.free_items), 1) + self.assertEqual(len(self.pool.free_items), 1) def dont_test_max_age(self): # This test is timing-sensitive. Rename the function without the "dont" to run it, but beware that it could fail or take a while. self.pool = self.create_pool(max_size=2, max_age=0.05) self.connection = self.pool.get() self.connection.close() - self.assertEquals(len(self.pool.free_items), 1) + self.assertEqual(len(self.pool.free_items), 1) api.sleep(0.01) # not long enough to trigger the age timeout - self.assertEquals(len(self.pool.free_items), 1) + self.assertEqual(len(self.pool.free_items), 1) self.connection = self.pool.get() self.connection.close() - self.assertEquals(len(self.pool.free_items), 1) + self.assertEqual(len(self.pool.free_items), 1) api.sleep(0.05) # long enough to trigger age timeout - self.assertEquals(len(self.pool.free_items), 0) + self.assertEqual(len(self.pool.free_items), 0) def dont_test_max_age_many(self): # This test is timing-sensitive. Rename the function without the "dont" to run it, but beware that it could fail or take a while. self.pool = self.create_pool(max_size=2, max_age=0.15) self.connection, conn2 = self.pool.get(), self.pool.get() self.connection.close() - self.assertEquals(len(self.pool.free_items), 1) + self.assertEqual(len(self.pool.free_items), 1) api.sleep(0) # not long enough to trigger the age timeout - self.assertEquals(len(self.pool.free_items), 1) + self.assertEqual(len(self.pool.free_items), 1) api.sleep(0.2) # long enough to trigger age timeout - self.assertEquals(len(self.pool.free_items), 0) + self.assertEqual(len(self.pool.free_items), 0) conn2.close() # should not be added to the free items - self.assertEquals(len(self.pool.free_items), 0) + self.assertEqual(len(self.pool.free_items), 0) def test_connection_timeout(self): # use a nonexistent ip address -- this one is reserved by IANA @@ -382,8 +382,8 @@ def test_waiters_get_woken(self): self.pool = self.create_pool(max_size=1, max_age=0) conn = self.pool.get() - self.assertEquals(self.pool.free(), 0) - self.assertEquals(self.pool.waiting(), 0) + self.assertEqual(self.pool.free(), 0) + self.assertEqual(self.pool.waiting(), 0) e = coros.event() def retrieve(pool, ev): c = pool.get() @@ -391,14 +391,14 @@ def retrieve(pool, ev): api.spawn(retrieve, self.pool, e) api.sleep(0) # these two sleeps should advance the retrieve api.sleep(0) # coroutine until it's waiting in get() - self.assertEquals(self.pool.free(), 0) - self.assertEquals(self.pool.waiting(), 1) + self.assertEqual(self.pool.free(), 0) + self.assertEqual(self.pool.waiting(), 1) self.pool.put(conn) timer = api.exc_after(0.3, api.TimeoutError) conn = e.wait() timer.cancel() - self.assertEquals(self.pool.free(), 0) - self.assertEquals(self.pool.waiting(), 0) + self.assertEqual(self.pool.free(), 0) + self.assertEqual(self.pool.waiting(), 0) def dont_test_0_straight_benchmark(self): """ Benchmark; don't run unless you want to wait a while.""" @@ -407,26 +407,26 @@ def dont_test_0_straight_benchmark(self): c = self.connection.cursor() self.connection.commit() def bench(c): - for i in xrange(iterations): + for i in range(iterations): c.execute('select 1') bench(c) # warm-up results = [] - for i in xrange(3): + for i in range(3): start = time.time() bench(c) end = time.time() results.append(end-start) - print "\n%u iterations took an average of %f seconds, (%s) in %s\n" % ( - iterations, sum(results)/len(results), results, type(self)) + print("\n%u iterations took an average of %f seconds, (%s) in %s\n" % ( + iterations, sum(results)/len(results), results, type(self))) def test_raising_create(self): # if the create() method raises an exception the pool should # not lose any connections self.pool = self.create_pool(max_size=1, module=RaisingDBModule()) self.assertRaises(RuntimeError, self.pool.get) - self.assertEquals(self.pool.free(), 1) + self.assertEqual(self.pool.free(), 1) class RaisingDBModule(object): @@ -485,8 +485,8 @@ def setUp(self): auth_utf8 = simplejson.load(open(os.path.join(os.path.dirname(__file__), 'auth.json'))) # have to convert unicode objects to str objects because mysqldb is dum self._auth = dict([(str(k), str(v)) - for k, v in auth_utf8.items()]) - except (IOError, ImportError), e: + for k, v in list(auth_utf8.items())]) + except (IOError, ImportError) as e: self._auth = {'host': 'localhost','user': 'root','passwd': '','db': 'persist0'} super(TestMysqlConnectionPool, self).setUp() @@ -527,7 +527,7 @@ class Test03MysqlRaw(TestMysqlConnectionPool, TestRawConnectionPool, TestCase): try: import MySQLdb except ImportError: - print "Unable to import MySQLdb, skipping db_pool_test." + print("Unable to import MySQLdb, skipping db_pool_test.") else: main() else: diff --git a/greentest/generate_report.py b/greentest/generate_report.py index 94b38f4..df0b7b0 100755 --- a/greentest/generate_report.py +++ b/greentest/generate_report.py @@ -1,4 +1,4 @@ -#!/usr/bin/python2 +#!/usr/bin/python3 # Copyright (c) 2008-2009 AG Projects # Author: Denis Bilenko @@ -49,14 +49,14 @@ def calc_hub_stats(table): for hub in table[testname]: test_result = table[testname][hub] hub_stats.setdefault(hub, TestResult(0,0,0,0)).__iadd__(test_result) - hubs = hub_stats.items() + hubs = list(hub_stats.items()) hub_names = sorted(hub_stats.keys()) def get_order(hub): try: return hubs_order.index(hub) except ValueError: return 100 + hub_names.index(hub) - hubs.sort(key=lambda (hub, stats): get_order(hub)) + hubs.sort(key=lambda hub_stats1: get_order(hub_stats1[0])) return hub_stats, [x[0] for x in hubs] class TestResult: @@ -206,7 +206,7 @@ def generate_raw_results(path, database): c = sqlite3.connect(database) res = c.execute('select id, stdout from command_record').fetchall() for id, out in res: - file(os.path.join(path, '%s.txt' % id), 'w').write(out.encode('utf-8')) + open(os.path.join(path, '%s.txt' % id), 'w').write(out) sys.stderr.write('.') sys.stderr.write('\n') @@ -219,16 +219,16 @@ def main(db): path = '../htmlreports/%s' % full_changeset try: os.makedirs(path) - except OSError, ex: + except OSError as ex: if 'File exists' not in str(ex): raise - file(path + '/index.html', 'w').write(report) + open(path + '/index.html', 'w').write(report) generate_raw_results(path, db) if __name__=='__main__': if not sys.argv[1:]: latest_db = sorted(glob.glob('results.*.db'), key=lambda f: os.stat(f).st_mtime)[-1] - print latest_db + print(latest_db) sys.argv.append(latest_db) for db in sys.argv[1:]: main(db) diff --git a/greentest/greenio_test.py b/greentest/greenio_test.py index 86fc508..1b07e0b 100644 --- a/greentest/greenio_test.py +++ b/greentest/greenio_test.py @@ -58,7 +58,7 @@ def did_it_work(server): client = api.connect_tcp(('127.0.0.1', server.getsockname()[1])) fd = client.makeGreenFile() client.close() - assert fd.readline() == 'hello\n' + assert fd.readline() == b'hello\n' assert fd.read() == '' fd.close() @@ -92,7 +92,7 @@ def accept_once(listener): client = api.connect_tcp(('127.0.0.1', server.getsockname()[1])) fd = client.makeGreenFile() client.close() - assert fd.read() == 'hello\n' + assert fd.read() == b'hello\n' assert fd.read() == '' timer.cancel() diff --git a/greentest/httpc_test.py b/greentest/httpc_test.py index 927ce89..9c93635 100644 --- a/greentest/httpc_test.py +++ b/greentest/httpc_test.py @@ -28,9 +28,9 @@ import time try: - from cStringIO import StringIO + from io import StringIO except ImportError: - from StringIO import StringIO + from io import StringIO class Site(object): @@ -43,7 +43,7 @@ def __call__(self, env, start_response): def _get_query_pairs(env): parsed = cgi.parse_qs(env['QUERY_STRING']) - for key, values in parsed.items(): + for key, values in list(parsed.items()): for val in values: yield key, val @@ -132,37 +132,37 @@ def test_get_bad_uri(self): def test_get(self): response = httpc.get(self.base_url() + 'hello') - self.assertEquals(response, 'hello world') + self.assertEqual(response, 'hello world') def test_get_(self): status, msg, body = httpc.get_(self.base_url() + 'hello') - self.assertEquals(status, 200) - self.assertEquals(msg.dict['x-get'], 'hello') - self.assertEquals(body, 'hello world') + self.assertEqual(status, 200) + self.assertEqual(msg.dict['x-get'], 'hello') + self.assertEqual(body, 'hello world') def test_get_query(self): response = httpc.get(self.base_url() + 'hello?foo=bar&foo=quux') - self.assertEquals(response, 'hello worldfoo=bar\nfoo=quux\n') + self.assertEqual(response, 'hello worldfoo=bar\nfoo=quux\n') def test_head_(self): status, msg, body = httpc.head_(self.base_url() + 'hello') - self.assertEquals(status, 200) - self.assertEquals(msg.dict['x-head'], 'hello') - self.assertEquals(body, '') + self.assertEqual(status, 200) + self.assertEqual(msg.dict['x-head'], 'hello') + self.assertEqual(body, '') def test_head(self): - self.assertEquals(httpc.head(self.base_url() + 'hello'), '') + self.assertEqual(httpc.head(self.base_url() + 'hello'), '') def test_post_(self): data = 'qunge' status, msg, body = httpc.post_(self.base_url() + '', data=data) - self.assertEquals(status, 200) - self.assertEquals(msg.dict['x-post'], 'hello') - self.assertEquals(body, data) + self.assertEqual(status, 200) + self.assertEqual(msg.dict['x-post'], 'hello') + self.assertEqual(body, data) def test_post(self): data = 'qunge' - self.assertEquals(httpc.post(self.base_url() + '', data=data), + self.assertEqual(httpc.post(self.base_url() + '', data=data), data) def test_put_bad_uri(self): @@ -172,40 +172,40 @@ def test_put_bad_uri(self): def test_put_empty(self): httpc.put(self.base_url() + 'empty', data='') - self.assertEquals(httpc.get(self.base_url() + 'empty'), '') + self.assertEqual(httpc.get(self.base_url() + 'empty'), '') def test_put_nonempty(self): data = 'nonempty' httpc.put(self.base_url() + 'nonempty', data=data) - self.assertEquals(httpc.get(self.base_url() + 'nonempty'), data) + self.assertEqual(httpc.get(self.base_url() + 'nonempty'), data) def test_put_01_create(self): data = 'goodbye world' status, msg, body = httpc.put_(self.base_url() + 'goodbye', data=data) - self.assertEquals(status, 201) - self.assertEquals(msg.dict['x-put'], 'hello') - self.assertEquals(body, '') - self.assertEquals(httpc.get(self.base_url() + 'goodbye'), data) + self.assertEqual(status, 201) + self.assertEqual(msg.dict['x-put'], 'hello') + self.assertEqual(body, '') + self.assertEqual(httpc.get(self.base_url() + 'goodbye'), data) def test_put_02_modify(self): self.test_put_01_create() data = 'i really mean goodbye' status = httpc.put_(self.base_url() + 'goodbye', data=data)[0] - self.assertEquals(status, 204) - self.assertEquals(httpc.get(self.base_url() + 'goodbye'), data) + self.assertEqual(status, 204) + self.assertEqual(httpc.get(self.base_url() + 'goodbye'), data) def test_delete_(self): httpc.put(self.base_url() + 'killme', data='killme') status, msg, body = httpc.delete_(self.base_url() + 'killme') - self.assertEquals(status, 204) + self.assertEqual(status, 204) self.assertRaises( httpc.NotFound, lambda: httpc.get(self.base_url() + 'killme')) def test_delete(self): httpc.put(self.base_url() + 'killme', data='killme') - self.assertEquals(httpc.delete(self.base_url() + 'killme'), '') + self.assertEqual(httpc.delete(self.base_url() + 'killme'), '') self.assertRaises( httpc.NotFound, lambda: httpc.get(self.base_url() + 'killme')) @@ -266,20 +266,20 @@ def base_url(self): def test_get(self): try: httpc.get(self.base_url() + 'hello', max_retries=0) - self.assert_(False) - except httpc.MovedPermanently, err: + self.assertTrue(False) + except httpc.MovedPermanently as err: response = err.retry() - self.assertEquals(response, 'hello world') - self.assertEquals(httpc.get(self.base_url() + 'hello', max_retries=1), 'hello world') + self.assertEqual(response, 'hello world') + self.assertEqual(httpc.get(self.base_url() + 'hello', max_retries=1), 'hello world') def test_post(self): data = 'qunge' try: response = httpc.post(self.base_url() + '', data=data) - self.assert_(False) - except httpc.MovedPermanently, err: + self.assertTrue(False) + except httpc.MovedPermanently as err: response = err.retry() - self.assertEquals(response, data) + self.assertEqual(response, data) class TestHttpc302(TestBase, TestCase): @@ -288,20 +288,20 @@ class TestHttpc302(TestBase, TestCase): def test_get_expired(self): try: httpc.get(self.base_url() + 'expired/hello', max_retries=0) - self.assert_(False) - except httpc.Found, err: + self.assertTrue(False) + except httpc.Found as err: response = err.retry() - self.assertEquals(response, 'hello world') - self.assertEquals(httpc.get(self.base_url() + 'expired/hello', max_retries=1), 'hello world') + self.assertEqual(response, 'hello world') + self.assertEqual(httpc.get(self.base_url() + 'expired/hello', max_retries=1), 'hello world') def test_get_expires(self): try: httpc.get(self.base_url() + 'expires/hello', max_retries=0) - self.assert_(False) - except httpc.Found, err: + self.assertTrue(False) + except httpc.Found as err: response = err.retry() - self.assertEquals(response, 'hello world') - self.assertEquals(httpc.get(self.base_url() + 'expires/hello', max_retries=1), 'hello world') + self.assertEqual(response, 'hello world') + self.assertEqual(httpc.get(self.base_url() + 'expires/hello', max_retries=1), 'hello world') class TestHttpc303(TestBase, TestCase): @@ -314,10 +314,10 @@ def test_post(self): data = 'hello world' try: response = httpc.post(self.base_url() + 'hello', data=data) - self.assert_(False) - except httpc.SeeOther, err: + self.assertTrue(False) + except httpc.SeeOther as err: response = err.retry() - self.assertEquals(response, data) + self.assertEqual(response, data) class TestHttpc307(TestBase, TestCase): @@ -330,10 +330,10 @@ def test_post(self): data = 'hello world' try: response = httpc.post(self.base_url() + 'hello', data=data) - self.assert_(False) - except httpc.TemporaryRedirect, err: + self.assertTrue(False) + except httpc.TemporaryRedirect as err: response = err.retry() - self.assertEquals(response, data) + self.assertEqual(response, data) class Site500(BasicSite): @@ -353,10 +353,10 @@ def test_get(self): try: response = httpc.get(self.base_url()) self.fail() - except httpc.InternalServerError, e: - self.assertEquals(e.params.response_body, data) - self.assert_(str(e).count(data)) - self.assert_(repr(e).count(data)) + except httpc.InternalServerError as e: + self.assertEqual(e.params.response_body, data) + self.assertTrue(str(e).count(data)) + self.assertTrue(repr(e).count(data)) class Site504(BasicSite): diff --git a/greentest/httpd_test.py b/greentest/httpd_test.py index 828df5c..bb49f64 100644 --- a/greentest/httpd_test.py +++ b/greentest/httpd_test.py @@ -29,9 +29,9 @@ from greentest import find_command try: - from cStringIO import StringIO + from io import StringIO except ImportError: - from StringIO import StringIO + from io import StringIO util.wrap_socket_with_coroutine_socket() @@ -105,8 +105,8 @@ def test_001_server(self): result = fd.read() fd.close() ## The server responds with the maximum version it supports - self.assert_(result.startswith('HTTP'), result) - self.assert_(result.endswith('hello world')) + self.assertTrue(result.startswith('HTTP'), result) + self.assertTrue(result.endswith('hello world')) def test_002_keepalive(self): sock = api.connect_tcp( @@ -149,7 +149,7 @@ def skip_test_005_run_apachebench(self): # ab is apachebench out = processes.Process(find_command('ab'), ['-c','64','-n','1024', '-k', url]) - print out.read() + print(out.read()) def test_006_reject_long_urls(self): sock = api.connect_tcp( diff --git a/greentest/parse_results.py b/greentest/parse_results.py index 633867f..dba43ea 100755 --- a/greentest/parse_results.py +++ b/greentest/parse_results.py @@ -1,4 +1,4 @@ -#!/usr/bin/python2 +#!/usr/bin/python3 # Copyright (c) 2008-2009 AG Projects # Author: Denis Bilenko @@ -29,6 +29,8 @@ import glob def parse_stdout(s): + if isinstance(s, bytes): + s = s.decode('utf-8') argv = re.search('^===ARGV=(.*?)$', s, re.M).group(1) argv = argv.split() testname = argv[-1] @@ -66,7 +68,7 @@ def parse_unittest_output(s): fail = int(fail or '0') error = int(error or '0') else: - assert ok_match, `s` + assert ok_match, repr(s) timeout_match = re.search('^===disabled because of timeout: (\d+)$', s, re.M) if timeout_match: timeout = int(timeout_match.group(1)) @@ -108,10 +110,10 @@ def main(db): except Exception: parse_error += 1 sys.stderr.write('Failed to parse id=%s\n' % id) - print repr(stdout) + print(repr(stdout)) traceback.print_exc() else: - print id, hub, testname, runs, errors, fails, timeouts + print(id, hub, testname, runs, errors, fails, timeouts) c.execute('insert into parsed_command_record ' '(id, testname, hub, runs, errors, fails, timeouts) ' 'values (?, ?, ?, ?, ?, ?, ?)', @@ -121,8 +123,8 @@ def main(db): if __name__=='__main__': if not sys.argv[1:]: latest_db = sorted(glob.glob('results.*.db'), key=lambda f: os.stat(f).st_mtime)[-1] - print latest_db + print(latest_db) sys.argv.append(latest_db) for db in sys.argv[1:]: main(db) - execfile('generate_report.py') + exec(compile(open('generate_report.py').read(), 'generate_report.py', 'exec')) diff --git a/greentest/pools_test.py b/greentest/pools_test.py index ed1f8f2..9de64ba 100644 --- a/greentest/pools_test.py +++ b/greentest/pools_test.py @@ -47,17 +47,17 @@ def test_integers(self): # with self.pool.some_api_name() as thing: # # do stuff - self.assertEquals(self.pool.get(), 1) - self.assertEquals(self.pool.get(), 2) - self.assertEquals(self.pool.get(), 3) - self.assertEquals(self.pool.get(), 4) + self.assertEqual(self.pool.get(), 1) + self.assertEqual(self.pool.get(), 2) + self.assertEqual(self.pool.get(), 3) + self.assertEqual(self.pool.get(), 4) def test_free(self): - self.assertEquals(self.pool.free(), 4) + self.assertEqual(self.pool.free(), 4) gotten = self.pool.get() - self.assertEquals(self.pool.free(), 3) + self.assertEqual(self.pool.free(), 3) self.pool.put(gotten) - self.assertEquals(self.pool.free(), 4) + self.assertEqual(self.pool.free(), 4) def test_exhaustion(self): waiter = coros.queue(0) @@ -72,7 +72,7 @@ def consumer(): one, two, three, four = ( self.pool.get(), self.pool.get(), self.pool.get(), self.pool.get()) - self.assertEquals(self.pool.free(), 0) + self.assertEqual(self.pool.free(), 0) # Let consumer run; nothing will be in the pool, so he will wait api.sleep(0) @@ -81,7 +81,7 @@ def consumer(): self.pool.put(one) # wait for the consumer - self.assertEquals(waiter.wait(), one) + self.assertEqual(waiter.wait(), one) def test_blocks_on_pool(self): waiter = coros.queue(0) @@ -91,7 +91,7 @@ def greedy(): self.pool.get() self.pool.get() # No one should be waiting yet. - self.assertEquals(self.pool.waiting(), 0) + self.assertEqual(self.pool.waiting(), 0) # The call to the next get will unschedule this routine. self.pool.get() # So this send should never be called. @@ -100,13 +100,13 @@ def greedy(): killable = api.spawn(greedy) # no one should be waiting yet. - self.assertEquals(self.pool.waiting(), 0) + self.assertEqual(self.pool.waiting(), 0) ## Wait for greedy api.sleep(0) ## Greedy should be blocking on the last get - self.assertEquals(self.pool.waiting(), 1) + self.assertEqual(self.pool.waiting(), 1) ## Send will never be called, so balance should be 0. self.assertFalse(waiter.ready()) @@ -119,8 +119,8 @@ def test_ordering(self): one, two = self.pool.get(), self.pool.get() self.pool.put(one) self.pool.put(two) - self.assertEquals(self.pool.get(), one) - self.assertEquals(self.pool.get(), two) + self.assertEqual(self.pool.get(), one) + self.assertEqual(self.pool.get(), two) def test_putting_to_queue(self): timer = api.exc_after(0.1, api.TimeoutError) @@ -131,11 +131,11 @@ def test_putting_to_queue(self): def just_put(pool_item, index): self.pool.put(pool_item) queue.send(index) - for index in xrange(size + 1): + for index in range(size + 1): pool_item = self.pool.get() api.spawn(just_put, pool_item, index) - while results != range(size + 1): + while results != list(range(size + 1)): x = queue.wait() results.append(x) timer.cancel() @@ -156,11 +156,11 @@ def setUp(self): self.pool = IntPool(min_size=3, max_size=3) def test_something(self): - self.assertEquals(len(self.pool.free_items), 3) + self.assertEqual(len(self.pool.free_items), 3) ## Cover the clause in get where we get from the free list instead of creating ## an item on get gotten = self.pool.get() - self.assertEquals(gotten, 1) + self.assertEqual(gotten, 1) class TestOrderAsStack(TestCase): @@ -173,8 +173,8 @@ def test_ordering(self): one, two = self.pool.get(), self.pool.get() self.pool.put(one) self.pool.put(two) - self.assertEquals(self.pool.get(), two) - self.assertEquals(self.pool.get(), one) + self.assertEqual(self.pool.get(), two) + self.assertEqual(self.pool.get(), one) class RaisePool(pools.Pool): @@ -188,9 +188,9 @@ def setUp(self): self.pool = RaisePool(max_size=3) def test_it(self): - self.assertEquals(self.pool.free(), 3) + self.assertEqual(self.pool.free(), 3) self.assertRaises(RuntimeError, self.pool.get) - self.assertEquals(self.pool.free(), 3) + self.assertEqual(self.pool.free(), 3) ALWAYS = RuntimeError('I always fail') @@ -218,19 +218,19 @@ def my_callable(pool_item, next_thing): return next_thing output = self.pool.fan(my_callable, list_of_input) - self.assertEquals(list_of_input, output) + self.assertEqual(list_of_input, output) def test_all_fail(self): def my_failure(pool_item, next_thing): raise ALWAYS - self.assertRaises(pools.AllFailed, self.pool.fan, my_failure, range(4)) + self.assertRaises(pools.AllFailed, self.pool.fan, my_failure, list(range(4))) def test_some_fail(self): def my_failing_callable(pool_item, next_thing): if next_thing % 2: raise SOMETIMES return next_thing - self.assertRaises(pools.SomeFailed, self.pool.fan, my_failing_callable, range(4)) + self.assertRaises(pools.SomeFailed, self.pool.fan, my_failing_callable, list(range(4))) if __name__ == '__main__': diff --git a/greentest/processes_test.py b/greentest/processes_test.py index 906034d..fce411d 100644 --- a/greentest/processes_test.py +++ b/greentest/processes_test.py @@ -36,7 +36,7 @@ def test_echo(self): result = proc.read() finally: self.pool.put(proc) - self.assertEquals(result, 'hello\n') + self.assertEqual(result, 'hello\n') def test_read_eof(self): proc = self.pool.get() @@ -62,7 +62,7 @@ def test_cat(self): finally: self.pool.put(proc) - self.assertEquals(result, 'goodbye') + self.assertEqual(result, 'goodbye') def test_write_to_dead(self): result = None @@ -97,14 +97,14 @@ def test_dead_process_not_inserted_into_pool(self): try: try: result = proc.read() - self.assertEquals(result, 'hello\n') + self.assertEqual(result, 'hello\n') result = proc.read() except processes.DeadProcess: pass finally: self.pool.put(proc) proc2 = self.pool.get() - self.assert_(proc is not proc2) + self.assertTrue(proc is not proc2) class TestProcessLivesForever(TestCase): @@ -117,15 +117,15 @@ def test_reading_twice_from_same_process(self): proc = self.pool.get() try: result = proc.read(2) - self.assertEquals(result, 'y\n') + self.assertEqual(result, 'y\n') finally: self.pool.put(proc) proc2 = self.pool.get() - self.assert_(proc is proc2, "This will fail if there is a timing issue") + self.assertTrue(proc is proc2, "This will fail if there is a timing issue") try: result = proc2.read(2) - self.assertEquals(result, 'y\n') + self.assertEqual(result, 'y\n') finally: self.pool.put(proc2) diff --git a/greentest/record_results.py b/greentest/record_results.py index 941d103..ec0113f 100755 --- a/greentest/record_results.py +++ b/greentest/record_results.py @@ -1,4 +1,4 @@ -#!/usr/bin/python2 +#!/usr/bin/python3 # Copyright (c) 2008-2009 AG Projects # Author: Denis Bilenko @@ -28,6 +28,7 @@ import sys import os import codecs +import tempfile try: import sqlite3 except ImportError: @@ -49,7 +50,7 @@ def record(changeset, argv, stdout, returncode): stdout text, exitcode integer)''') c.execute('insert into command_record (command, stdout, exitcode)' - 'values (?, ?, ?)', (`argv`, stdout, returncode)) + 'values (?, ?, ?)', (repr(argv), stdout, returncode)) c.commit() def main(): @@ -60,12 +61,13 @@ def main(): else: debug = False changeset = os.popen(COMMAND_CHANGESET).readlines()[0].replace('changeset:', '').strip().replace(':', '_') - output_name = os.tmpnam() - arg = ' '.join(argv) + ' &> %s' % output_name - print arg + output_fd = tempfile.NamedTemporaryFile(delete=False) + output_name = output_fd.name + arg = ' '.join(argv) + ' > %s' % output_name returncode = os.system(arg)>>8 - print arg, 'finished with code', returncode + print(arg, 'finished with code', returncode) stdout = codecs.open(output_name, mode='r', encoding='utf-8', errors='replace').read().replace('\x00', '?') + print(">>>\n", stdout, "\n<<<\n") if not debug: if returncode==1: pass @@ -73,7 +75,7 @@ def main(): pass else: record(changeset, argv, stdout, returncode) - os.unlink(output_name) + #os.unlink(output_name) sys.exit(returncode) if __name__=='__main__': diff --git a/greentest/runall.py b/greentest/runall.py index 0b5fd2e..d3e7743 100755 --- a/greentest/runall.py +++ b/greentest/runall.py @@ -1,4 +1,4 @@ -#!/usr/bin/python2 +#!/usr/bin/python3 # Copyright (c) 2008-2009 AG Projects # Author: Denis Bilenko @@ -57,8 +57,8 @@ def enum_hubs(): for hub in hubs: try: use_hub(hub) - except Exception, ex: - print 'Skipping hub %s: %s' % (hub, ex) + except Exception as ex: + print('Skipping hub %s: %s' % (hub, ex)) else: result.append(hub) return result @@ -76,8 +76,8 @@ def enum_reactors(): for reactor in all_reactors: try: import_reactor(reactor) - except Exception, ex: - print 'Skipping reactor %s: %s' % (reactor, ex) + except Exception as ex: + print('Skipping reactor %s: %s' % (reactor, ex)) else: selected_reactors.append(reactor) return selected_reactors @@ -140,9 +140,9 @@ def main(): options.reactors.sort(key=first_reactors.__contains__, reverse=True) random.shuffle(options.tests) - print 'hubs: %s' % ','.join(options.hubs) - print 'reactors: %s' % ','.join(options.reactors) - print 'tests: %s' % ','.join(options.tests) + print('hubs: %s' % ','.join(options.hubs)) + print('reactors: %s' % ','.join(options.reactors)) + print('tests: %s' % ','.join(options.tests)) if options.show: return diff --git a/greentest/saranwrap_test.py b/greentest/saranwrap_test.py index e6c5914..28f3938 100755 --- a/greentest/saranwrap_test.py +++ b/greentest/saranwrap_test.py @@ -1,4 +1,4 @@ -#!/usr/bin/python2 +#!/usr/bin/python3 # @file test_saranwrap.py # @brief Test cases for saranwrap. @@ -57,7 +57,7 @@ def get_dict(self): class TestSaranwrap(unittest.TestCase): def assert_server_exists(self, prox): - self.assert_(saranwrap.status(prox)) + self.assertTrue(saranwrap.status(prox)) prox.foo = 0 self.assertEqual(0, prox.foo) @@ -89,18 +89,18 @@ def key(): def test_wrap_dict(self): my_object = {'a':1} prox = saranwrap.wrap(my_object) - self.assertEqual('a', prox.keys()[0]) + self.assertEqual('a', list(prox.keys())[0]) self.assertEqual(1, prox['a']) self.assertEqual(str(my_object), str(prox)) self.assertEqual('saran:' + repr(my_object), repr(prox)) - self.assertEqual('saran:' + `my_object`, `prox`) + self.assertEqual('saran:' + repr(my_object), repr(prox)) def test_wrap_module_class(self): prox = saranwrap.wrap(uuid) self.assertEqual(saranwrap.Proxy, type(prox)) id = prox.uuid4() self.assertEqual(id.get_version(), uuid.uuid4().get_version()) - self.assert_(repr(prox.uuid4)) + self.assertTrue(repr(prox.uuid4)) def test_wrap_eq(self): prox = saranwrap.wrap(uuid) @@ -108,14 +108,14 @@ def test_wrap_eq(self): id2 = prox.UUID(str(id1)) self.assertEqual(id1, id2) id3 = prox.uuid4() - self.assert_(id1 != id3) + self.assertTrue(id1 != id3) def test_wrap_nonzero(self): prox = saranwrap.wrap(uuid) id1 = prox.uuid4() - self.assert_(bool(id1)) + self.assertTrue(bool(id1)) prox2 = saranwrap.wrap([1, 2, 3]) - self.assert_(bool(prox2)) + self.assertTrue(bool(prox2)) def test_multiple_wraps(self): prox1 = saranwrap.wrap(uuid) @@ -134,7 +134,7 @@ def test_dict_passthru(self): def test_is_value(self): server = saranwrap.Server(None, None, None) - self.assert_(server.is_value(None)) + self.assertTrue(server.is_value(None)) def test_wrap_getitem(self): prox = saranwrap.wrap([0,1,2]) @@ -156,7 +156,7 @@ def test_raising_weird_exceptions(self): prox = saranwrap.wrap(saranwrap) try: prox.raise_a_weird_error() - self.assert_(False) + self.assertTrue(False) except: import sys ex = sys.exc_info()[0] @@ -192,7 +192,7 @@ def test_stderr_does_not_break_wrapper(self): self.assert_server_exists(prox) def assertLessThan(self, a, b): - self.assert_(a < b, "%s is not less than %s" % (a, b)) + self.assertTrue(a < b, "%s is not less than %s" % (a, b)) def test_status(self): prox = saranwrap.wrap(time) @@ -200,7 +200,7 @@ def test_status(self): status = saranwrap.status(prox) self.assertEqual(status['object_count'], 1) self.assertEqual(status['next_id'], 2) - self.assert_(status['pid']) # can't guess what it will be + self.assertTrue(status['pid']) # can't guess what it will be # status of an object should be the same as the module self.assertEqual(saranwrap.status(a), status) # create a new one then immediately delete it @@ -210,7 +210,7 @@ def test_status(self): self.assertEqual(status['object_count'], 1) self.assertEqual(status['next_id'], 3) prox2 = saranwrap.wrap(uuid) - self.assert_(status['pid'] != saranwrap.status(prox2)['pid']) + self.assertTrue(status['pid'] != saranwrap.status(prox2)['pid']) def test_del(self): prox = saranwrap.wrap(time) @@ -227,8 +227,8 @@ def test_del(self): def test_contains(self): prox = saranwrap.wrap({'a':'b'}) - self.assert_('a' in prox) - self.assert_('x' not in prox) + self.assertTrue('a' in prox) + self.assertTrue('x' not in prox) def test_variable_and_keyword_arguments_with_function_calls(self): import optparse @@ -256,8 +256,8 @@ def make_list(): def test_status_of_none(self): try: saranwrap.status(None) - self.assert_(False) - except AttributeError, e: + self.assertTrue(False) + except AttributeError as e: pass def test_not_inheriting_pythonpath(self): @@ -271,11 +271,11 @@ def test_not_inheriting_pythonpath(self): # this should fail because we haven't stuck the temp_dir in our path yet prox = saranwrap.wrap_module('jitar_hero') - import cPickle + import pickle try: prox.pypath self.fail() - except cPickle.UnpicklingError: + except pickle.UnpicklingError: pass # now try to saranwrap it @@ -283,8 +283,8 @@ def test_not_inheriting_pythonpath(self): try: import jitar_hero prox = saranwrap.wrap(jitar_hero) - self.assert_(prox.pypath.count(temp_dir)) - self.assert_(prox.sys_path.count(temp_dir)) + self.assertTrue(prox.pypath.count(temp_dir)) + self.assertTrue(prox.sys_path.count(temp_dir)) finally: import shutil shutil.rmtree(temp_dir) @@ -296,9 +296,9 @@ def test_contention(self): pool = Pool(max_size=4) waiters = [] - waiters.append(pool.execute(lambda: self.assertEquals(prox.one, 1))) - waiters.append(pool.execute(lambda: self.assertEquals(prox.two, 2))) - waiters.append(pool.execute(lambda: self.assertEquals(prox.three, 3))) + waiters.append(pool.execute(lambda: self.assertEqual(prox.one, 1))) + waiters.append(pool.execute(lambda: self.assertEqual(prox.two, 2))) + waiters.append(pool.execute(lambda: self.assertEqual(prox.three, 3))) for waiter in waiters: waiter.wait() @@ -307,9 +307,9 @@ def test_copy(self): compound_object = {'a':[1,2,3]} prox = saranwrap.wrap(compound_object) def make_assertions(copied): - self.assert_(isinstance(copied, dict)) - self.assert_(isinstance(copied['a'], list)) - self.assertEquals(copied, compound_object) + self.assertTrue(isinstance(copied, dict)) + self.assertTrue(isinstance(copied['a'], list)) + self.assertEqual(copied, compound_object) self.assertNotEqual(id(compound_object), id(copied)) make_assertions(copy.copy(prox)) @@ -319,7 +319,7 @@ def test_list_of_functions(self): return # this test is known to fail, we can implement it sometime in the future if we wish from greentest import saranwrap_test prox = saranwrap.wrap([saranwrap_test.list_maker]) - self.assertEquals(list_maker(), prox[0]()) + self.assertEqual(list_maker(), prox[0]()) def test_under_the_hood_coroutines(self): # so, we want to write a class which uses a coroutine to call @@ -335,7 +335,7 @@ def test_under_the_hood_coroutines(self): # we check the assert below api.sleep(0.1) - self.assert_( + self.assertTrue( 'random' in obj_proxy.get_dict(), 'Coroutine in saranwrapped object did not run') diff --git a/greentest/test__api_timeout.py b/greentest/test__api_timeout.py index c5bea8a..63e26d5 100644 --- a/greentest/test__api_timeout.py +++ b/greentest/test__api_timeout.py @@ -19,7 +19,7 @@ # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN # THE SOFTWARE. -from __future__ import with_statement + import sys import unittest import weakref @@ -51,7 +51,7 @@ def test_api(self): try: with timeout(DELAY, IOError("Operation takes way too long")): sleep(DELAY*2) - except IOError, ex: + except IOError as ex: assert str(ex)=="Operation takes way too long", repr(ex) # Providing classes instead of values should be possible too: diff --git a/greentest/test__coros_queue.py b/greentest/test__coros_queue.py index cd0a2aa..058f892 100644 --- a/greentest/test__coros_queue.py +++ b/greentest/test__coros_queue.py @@ -13,7 +13,7 @@ class TestQueue(LimitedTestCase): def test_send_first(self): q = coros.queue() q.send('hi') - self.assertEquals(q.wait(), 'hi') + self.assertEqual(q.wait(), 'hi') def test_send_exception_first(self): q = coros.queue() @@ -24,7 +24,7 @@ def test_send_last(self): q = coros.queue() def waiter(q): timer = api.exc_after(0.1, api.TimeoutError) - self.assertEquals(q.wait(), 'hi2') + self.assertEqual(q.wait(), 'hi2') timer.cancel() api.spawn(waiter, q) @@ -46,12 +46,12 @@ def putter(q): api.spawn(putter, q) api.sleep(0) - self.assertEquals(results, ['a', 'b']) - self.assertEquals(q.wait(), 'a') + self.assertEqual(results, ['a', 'b']) + self.assertEqual(q.wait(), 'a') api.sleep(0) - self.assertEquals(results, ['a', 'b', 'c']) - self.assertEquals(q.wait(), 'b') - self.assertEquals(q.wait(), 'c') + self.assertEqual(results, ['a', 'b', 'c']) + self.assertEqual(q.wait(), 'b') + self.assertEqual(q.wait(), 'c') def test_zero_max_size(self): q = coros.queue(0) @@ -68,10 +68,10 @@ def receiver(evt, q): api.spawn(sender, e1, q) api.sleep(0) - self.assert_(not e1.ready()) + self.assertTrue(not e1.ready()) api.spawn(receiver, e2, q) - self.assertEquals(e2.wait(),'hi') - self.assertEquals(e1.wait(),'done') + self.assertEqual(e2.wait(),'hi') + self.assertEqual(e1.wait(),'done') def test_multiple_waiters(self): # tests that multiple waiters get their results back @@ -99,12 +99,12 @@ def collect_pending_results(): pass # no pending result at that event return len(results) q.send(sendings[0]) - self.assertEquals(collect_pending_results(), 1) + self.assertEqual(collect_pending_results(), 1) q.send(sendings[1]) - self.assertEquals(collect_pending_results(), 2) + self.assertEqual(collect_pending_results(), 2) q.send(sendings[2]) q.send(sendings[3]) - self.assertEquals(collect_pending_results(), 4) + self.assertEqual(collect_pending_results(), 4) def test_waiters_that_cancel(self): q = coros.queue() @@ -120,10 +120,10 @@ def do_receive(q, evt): evt = coros.event() api.spawn(do_receive, q, evt) - self.assertEquals(evt.wait(), 'timed out') + self.assertEqual(evt.wait(), 'timed out') q.send('hi') - self.assertEquals(q.wait(), 'hi') + self.assertEqual(q.wait(), 'hi') def test_senders_that_die(self): q = coros.queue() @@ -132,7 +132,7 @@ def do_send(q): q.send('sent') api.spawn(do_send, q) - self.assertEquals(q.wait(), 'sent') + self.assertEqual(q.wait(), 'sent') def test_two_waiters_one_dies(self): def waiter(q, evt): @@ -152,8 +152,8 @@ def do_receive(q, evt): api.spawn(waiter, q, waiting_evt) api.sleep(0) q.send('hi') - self.assertEquals(dying_evt.wait(), 'timed out') - self.assertEquals(waiting_evt.wait(), 'hi') + self.assertEqual(dying_evt.wait(), 'timed out') + self.assertEqual(waiting_evt.wait(), 'hi') def test_two_bogus_waiters(self): def do_receive(q, evt): @@ -171,9 +171,9 @@ def do_receive(q, evt): api.spawn(do_receive, q, e2) api.sleep(0) q.send('sent') - self.assertEquals(e1.wait(), 'timed out') - self.assertEquals(e2.wait(), 'timed out') - self.assertEquals(q.wait(), 'sent') + self.assertEqual(e1.wait(), 'timed out') + self.assertEqual(e2.wait(), 'timed out') + self.assertEqual(q.wait(), 'sent') def test_waiting(self): def do_wait(q, evt): @@ -184,12 +184,12 @@ def do_wait(q, evt): e1 = coros.event() api.spawn(do_wait, q, e1) api.sleep(0) - self.assertEquals(1, waiting(q)) + self.assertEqual(1, waiting(q)) q.send('hi') api.sleep(0) - self.assertEquals(0, waiting(q)) - self.assertEquals('hi', e1.wait()) - self.assertEquals(0, waiting(q)) + self.assertEqual(0, waiting(q)) + self.assertEqual('hi', e1.wait()) + self.assertEqual(0, waiting(q)) if __name__=='__main__': main() diff --git a/greentest/test__doctests.py b/greentest/test__doctests.py index 168432c..6182ee2 100644 --- a/greentest/test__doctests.py +++ b/greentest/test__doctests.py @@ -23,10 +23,10 @@ for m, path in modules: if re.search('^\s*>>> ', open(path).read(), re.M): s = doctest.DocTestSuite(m) - print '%s (from %s): %s tests' % (m, path, len(s._tests)) + print('%s (from %s): %s tests' % (m, path, len(s._tests))) suite.addTest(s) modules_count += 1 tests_count += len(s._tests) -print 'Total: %s tests in %s modules' % (tests_count, modules_count) +print('Total: %s tests in %s modules' % (tests_count, modules_count)) runner = unittest.TextTestRunner(verbosity=2) runner.run(suite) diff --git a/greentest/test__event.py b/greentest/test__event.py index 048eae8..9652eaf 100644 --- a/greentest/test__event.py +++ b/greentest/test__event.py @@ -36,7 +36,7 @@ def waiter(): try: result = e.wait() log.append(('received', result)) - except Exception, ex: + except Exception as ex: log.append(('catched', ex)) spawn(waiter) sleep(0) # let waiter to block on e.wait() diff --git a/greentest/test__greenness.py b/greentest/test__greenness.py index 806832c..e0d4fed 100644 --- a/greentest/test__greenness.py +++ b/greentest/test__greenness.py @@ -55,10 +55,10 @@ def tearDown(self): def test_urllib2(self): self.assertEqual(self.server.request_count, 0) try: - urllib2.urlopen('http://127.0.0.1:%s' % port) + urllib.request.urlopen('http://127.0.0.1:%s' % port) assert False, 'should not get there' - except urllib2.HTTPError, ex: - assert ex.code == 501, `ex` + except urllib.error.HTTPError as ex: + assert ex.code == 501, repr(ex) self.assertEqual(self.server.request_count, 1) if __name__ == '__main__': diff --git a/greentest/test__pool.py b/greentest/test__pool.py index 385a804..139a7d8 100644 --- a/greentest/test__pool.py +++ b/greentest/test__pool.py @@ -37,7 +37,7 @@ def consumer(): done = pool.execute(consumer) pool.execute_async(producer) done.wait() - self.assertEquals(['cons1', 'prod', 'cons2'], results) + self.assertEqual(['cons1', 'prod', 'cons2'], results) def test_timer_cancel(self): # this test verifies that local timers are not fired @@ -51,7 +51,7 @@ def some_work(): worker = pool.execute(some_work) worker.wait() api.sleep(0) - self.assertEquals(timer_fired, []) + self.assertEqual(timer_fired, []) def test_reentrant(self): pool = self.klass(0,1) @@ -118,7 +118,7 @@ def slow(): api.sleep(0.1) return 'ok' pool.execute(slow) - self.assertEquals(pool.wait(), 'ok') + self.assertEqual(pool.wait(), 'ok') def test_pool_smash(self): # The premise is that a coroutine in a Pool tries to get a token out @@ -139,7 +139,7 @@ def do_receive(tp): # the execute makes the token pool expect that coroutine, but then # immediately cuts bait e1 = pool.execute(do_receive, tp) - self.assertEquals(e1.wait(), 'timed out') + self.assertEqual(e1.wait(), 'timed out') # the pool can get some random item back def send_wakeup(tp): @@ -151,10 +151,10 @@ def send_wakeup(tp): def resume(): return 'resumed' e2 = pool.execute(resume) - self.assertEquals(e2.wait(), 'resumed') + self.assertEqual(e2.wait(), 'resumed') # we should be able to get out the thing we put in there, too - self.assertEquals(tp.get(), 'wakeup') + self.assertEqual(tp.get(), 'wakeup') class PoolBasicTests(LimitedTestCase): diff --git a/greentest/test__proc.py b/greentest/test__proc.py index 560e5e3..f94a877 100644 --- a/greentest/test__proc.py +++ b/greentest/test__proc.py @@ -84,7 +84,7 @@ def test_event(self): p.link(event) self.assertEqual(event.wait(), 100) - for i in xrange(3): + for i in range(3): event2 = coros.event() p.link(event2) self.assertEqual(event2.wait(), 100) @@ -168,7 +168,7 @@ def return25(): p = self.p = proc.spawn(return25) self._test_return(p, True, 25, proc.LinkedCompleted, lambda : sleep(0)) # repeating the same with dead process - for _ in xrange(3): + for _ in range(3): self._test_return(p, False, 25, proc.LinkedCompleted, lambda : sleep(0)) def _test_return(self, p, first_time, result, kill_exc_type, action): @@ -232,7 +232,7 @@ def test_raise(self): p = self.p = proc.spawn(int, 'badint') self._test_raise(p, True, proc.LinkedFailed) # repeating the same with dead process - for _ in xrange(3): + for _ in range(3): self._test_raise(p, False, proc.LinkedFailed) def _test_kill(self, p, first_time, kill_exc_type): @@ -264,7 +264,7 @@ def test_kill(self): p = self.p = proc.spawn(sleep, DELAY) self._test_kill(p, True, proc.LinkedKilled) # repeating the same with dead process - for _ in xrange(3): + for _ in range(3): self._test_kill(p, False, proc.LinkedKilled) class TestRaise_link_exception(TestCase): @@ -312,7 +312,7 @@ def badint(): b = proc.spawn(int, 'second') try: proc.waitall([a, b]) - except ValueError, ex: + except ValueError as ex: assert 'second' in str(ex), repr(str(ex)) def test_multiple_listeners_error(self): diff --git a/greentest/test__refcount.py b/greentest/test__refcount.py index 139469b..9e4b5d1 100644 --- a/greentest/test__refcount.py +++ b/greentest/test__refcount.py @@ -52,7 +52,7 @@ def handle_request(s, raise_on_timeout): return #print 'handle_request - accepted' res = conn.recv(100) - assert res == 'hello', `res` + assert res == 'hello', repr(res) #print 'handle_request - recvd %r' % res res = conn.send('bye') #print 'handle_request - sent %r' % res @@ -67,7 +67,7 @@ def make_request(): res = s.send('hello') #print 'make_request - sent %s' % res res = s.recv(100) - assert res == 'bye', `res` + assert res == 'bye', repr(res) #print 'make_request - recvd %r' % res #s.close() @@ -84,11 +84,11 @@ def run_interaction(run_client): def run_and_check(run_client): w = run_interaction(run_client=run_client) if w(): - print gc.get_referrers(w()) + print(gc.get_referrers(w())) for x in gc.get_referrers(w()): - print x + print(x) for y in gc.get_referrers(x): - print '-', y + print('-', y) raise AssertionError('server should be dead by now') class test(unittest.TestCase): diff --git a/greentest/test__socket_errors.py b/greentest/test__socket_errors.py index a137d74..2f70a3d 100644 --- a/greentest/test__socket_errors.py +++ b/greentest/test__socket_errors.py @@ -33,7 +33,7 @@ def test_connection_refused(self): s = socket.socket() try: s.connect(('127.0.0.1', 81)) - except socket.error, ex: + except socket.error as ex: code, text = ex.args assert code in [111, 61], (code, text) assert 'refused' in text.lower(), (code, text) diff --git a/greentest/test__twistedutil.py b/greentest/test__twistedutil.py index 28cf5cd..d516ebf 100644 --- a/greentest/test__twistedutil.py +++ b/greentest/test__twistedutil.py @@ -46,7 +46,7 @@ def test_block_on_fail(self): def test_block_on_already_succeed(self): d = defer.succeed('hey corotwine') res = block_on(d) - assert res == 'hey corotwine', `res` + assert res == 'hey corotwine', repr(res) def test_block_on_already_failed(self): d = defer.fail(Failure(ZeroDivisionError())) diff --git a/greentest/test__twistedutil_protocol.py b/greentest/test__twistedutil_protocol.py index 6d84af5..f6f25c4 100644 --- a/greentest/test__twistedutil_protocol.py +++ b/greentest/test__twistedutil_protocol.py @@ -130,7 +130,7 @@ def test_iterator(self): self.conn.write('iterator\r\n') self.assertEqual('you said iterator. BYE', ''.join(self.conn)) - _tests = [x for x in locals().keys() if x.startswith('test_')] + _tests = [x for x in list(locals().keys()) if x.startswith('test_')] def test_resume_producing(self): for test in self._tests: diff --git a/greentest/test_socket.py b/greentest/test_socket.py index be0f234..ccf79d3 100755 --- a/greentest/test_socket.py +++ b/greentest/test_socket.py @@ -1,4 +1,4 @@ -#!/usr/bin/python2 +#!/usr/bin/python3 import unittest from greentest import test_support @@ -7,7 +7,7 @@ from eventlib.green import select from eventlib.green import time from eventlib.green import thread, threading -import Queue +import queue import sys import array from weakref import proxy @@ -15,7 +15,7 @@ PORT = 50007 HOST = 'localhost' -MSG = 'Michael Gilfix was here\n' +MSG = b'Michael Gilfix was here\n' class SocketTCPTest(unittest.TestCase): @@ -98,7 +98,7 @@ def _setUp(self): self.server_ready = threading.Event() self.client_ready = threading.Event() self.done = threading.Event() - self.queue = Queue.Queue(1) + self.queue = queue.Queue(1) # Do some munging to start the client test. methodname = self.id() @@ -126,15 +126,15 @@ def clientRun(self, test_func): self.client_ready.set() self.clientSetUp() if not callable(test_func): - raise TypeError, "test_func must be a callable function" + raise TypeError("test_func must be a callable function") try: test_func() - except Exception, strerror: + except Exception as strerror: self.queue.put(strerror) self.clientTearDown() def clientSetUp(self): - raise NotImplementedError, "clientSetUp must be implemented." + raise NotImplementedError("clientSetUp must be implemented.") def clientTearDown(self): self.done.set() @@ -239,11 +239,11 @@ def raise_herror(*args, **kwargs): raise socket.herror def raise_gaierror(*args, **kwargs): raise socket.gaierror - self.failUnlessRaises(socket.error, raise_error, + self.assertRaises(socket.error, raise_error, "Error raising socket exception.") - self.failUnlessRaises(socket.error, raise_herror, + self.assertRaises(socket.error, raise_herror, "Error raising socket exception.") - self.failUnlessRaises(socket.error, raise_gaierror, + self.assertRaises(socket.error, raise_gaierror, "Error raising socket exception.") def testCrucialConstants(self): @@ -265,7 +265,7 @@ def testHostnameRes(self): except socket.error: # Probably name lookup wasn't set up right; skip this test return - self.assert_(ip.find('.') >= 0, "Error resolving host to ip.") + self.assertTrue(ip.find('.') >= 0, "Error resolving host to ip.") try: hname, aliases, ipaddrs = socket.gethostbyaddr(ip) except socket.error: @@ -285,7 +285,7 @@ def testRefCountGetNameInfo(self): orig = sys.getrefcount(__name__) socket.getnameinfo(__name__,0) except SystemError: - if sys.getrefcount(__name__) <> orig: + if sys.getrefcount(__name__) != orig: self.fail("socket.getnameinfo loses a reference") def testInterpreterCrash(self): @@ -301,14 +301,14 @@ def testNtoH(self): # when looking at the lower 16 or 32 bits. sizes = {socket.htonl: 32, socket.ntohl: 32, socket.htons: 16, socket.ntohs: 16} - for func, size in sizes.items(): - mask = (1L<> sys.stderr, """\ + print("""\ WARNING: an attempt to connect to %r %s, in test_timeout. That may be legitimate, but is not the outcome we hoped for. If this message is seen often, test_timeout should be changed to - use a more reliable address.""" % (ADDR, extra_msg) + use a more reliable address.""" % (ADDR, extra_msg), file=sys.stderr) if test_support.verbose: - print "test_timeout ..." + print("test_timeout ...") # A service which issues a welcome banner (without need to write # anything). @@ -56,7 +56,7 @@ def error_msg(extra_msg): except socket.timeout: error_msg('timed out') return - except socket.error, exc: # In case connection is refused. + except socket.error as exc: # In case connection is refused. if exc.args[0] == errno.ECONNREFUSED: error_msg('was refused') return @@ -71,7 +71,7 @@ def error_msg(extra_msg): def test_rude_shutdown(): if test_support.verbose: - print "test_rude_shutdown ..." + print("test_rude_shutdown ...") from eventlib.green import threading @@ -115,7 +115,7 @@ def connector(): def test_rude_shutdown__write(): if test_support.verbose: - print "test_rude_shutdown__variant ..." + print("test_rude_shutdown__variant ...") from eventlib.green import threading diff --git a/greentest/test_socketserver.py b/greentest/test_socketserver.py index bde3409..cf4a9f6 100644 --- a/greentest/test_socketserver.py +++ b/greentest/test_socketserver.py @@ -48,7 +48,7 @@ def receive(sock, n, timeout=5): if sock in r: return sock.recv(n) else: - raise RuntimeError, "timed out on %r" % (sock,) + raise RuntimeError("timed out on %r" % (sock,)) def testdgram(proto, addr): s = socket.socket(proto, socket.SOCK_DGRAM) @@ -80,7 +80,7 @@ def __init__(self, addr, svrcls, hdlrcls): def run(self): class svrcls(MyMixinServer, self.__svrcls): pass - if verbose: print "thread: creating server" + if verbose: print("thread: creating server") svr = svrcls(self.__addr, self.__hdlrcls) # pull the address out of the server in case it changed # this can happen if another process is using the port @@ -91,9 +91,9 @@ class svrcls(MyMixinServer, self.__svrcls): if self.__addr != svr.socket.getsockname(): raise RuntimeError('server_address was %s, expected %s' % (self.__addr, svr.socket.getsockname())) - if verbose: print "thread: serving three times" + if verbose: print("thread: serving three times") svr.serve_a_few() - if verbose: print "thread: done" + if verbose: print("thread: done") seed = 0 def pickport(): @@ -136,19 +136,19 @@ def testloop(proto, servers, hdlrcls, testfunc): for svrcls in servers: addr = pickaddr(proto) if verbose: - print "ADDR =", addr - print "CLASS =", svrcls + print("ADDR =", addr) + print("CLASS =", svrcls) t = ServerThread(addr, svrcls, hdlrcls) - if verbose: print "server created" + if verbose: print("server created") t.start() - if verbose: print "server running" + if verbose: print("server running") for i in range(NREQ): time.sleep(DELAY) - if verbose: print "test client", i + if verbose: print("test client", i) testfunc(proto, addr) - if verbose: print "waiting for server" + if verbose: print("waiting for server") t.join() - if verbose: print "done" + if verbose: print("done") class ForgivingTCPServer(TCPServer): # prevent errors if another process is using the port we want @@ -162,11 +162,11 @@ def server_bind(self): self.server_address = host, port TCPServer.server_bind(self) break - except socket.error, (err, msg): + except socket.error as error: + (err, msg) = error.args if err != errno.EADDRINUSE: raise - print >>sys.__stderr__, \ - ' WARNING: failed to listen on port %d, trying another' % port + print(' WARNING: failed to listen on port %d, trying another' % port, file=sys.__stderr__) tcpservers = [ForgivingTCPServer, ThreadingTCPServer] if hasattr(os, 'fork') and os.name not in ('os2',): @@ -214,16 +214,16 @@ def tearDown(self): for tcpserver in tcpservers: n = tcpserver.__name__ - exec """def test_%s(self): testloop(socket.AF_INET, [%s], MyStreamHandler, teststream)""" % (n,n) + exec("""def test_%s(self): testloop(socket.AF_INET, [%s], MyStreamHandler, teststream)""" % (n,n)) for udpserver in udpservers: n = udpserver.__name__ - exec """def test_%s(self): testloop(socket.AF_INET, [%s], MyDatagramHandler, testdgram)""" % (n,n) + exec("""def test_%s(self): testloop(socket.AF_INET, [%s], MyDatagramHandler, testdgram)""" % (n,n)) if hasattr(socket, 'AF_UNIX'): for streamserver in streamservers: n = streamserver.__name__ - exec """def test_%s(self): testloop(socket.AF_UNIX, [%s], MyStreamHandler, teststream)""" % (n,n) + exec("""def test_%s(self): testloop(socket.AF_UNIX, [%s], MyStreamHandler, teststream)""" % (n,n)) def testall(): diff --git a/greentest/test_support.py b/greentest/test_support.py index 58c8404..506f04f 100644 --- a/greentest/test_support.py +++ b/greentest/test_support.py @@ -1,7 +1,7 @@ """Supporting definitions for the Python regression tests.""" if __name__ != 'greentest.test_support': - raise ImportError, 'test_support must be imported from the test package' + raise ImportError('test_support must be imported from the test package') import sys @@ -111,12 +111,12 @@ def bind_port(sock, host='', preferred_port=54321): if port == 0: port = sock.getsockname()[1] return port - except socket.error, (err, msg): + except socket.error as error: + (err, msg) = error.args if err != errno.EADDRINUSE: raise - print >>sys.__stderr__, \ - ' WARNING: failed to listen on port %d, trying another' % port - raise TestFailed, 'unable to find port to listen on' + print(' WARNING: failed to listen on port %d, trying another' % port, file=sys.__stderr__) + raise TestFailed('unable to find port to listen on') FUZZ = 1e-6 @@ -138,7 +138,7 @@ def fcmp(x, y): # fuzzy comparison function return cmp(x, y) try: - unicode + str have_unicode = 1 except NameError: have_unicode = 0 @@ -159,13 +159,13 @@ def fcmp(x, y): # fuzzy comparison function # Assuming sys.getfilesystemencoding()!=sys.getdefaultencoding() # TESTFN_UNICODE is a filename that can be encoded using the # file system encoding, but *not* with the default (ascii) encoding - if isinstance('', unicode): + if isinstance('', str): # python -U # XXX perhaps unicode() should accept Unicode strings? TESTFN_UNICODE = "@test-\xe0\xf2" else: # 2 latin characters. - TESTFN_UNICODE = unicode("@test-\xe0\xf2", "latin-1") + TESTFN_UNICODE = str("@test-\xe0\xf2", "latin-1") TESTFN_ENCODING = sys.getfilesystemencoding() # TESTFN_UNICODE_UNENCODEABLE is a filename that should *not* be # able to be encoded by *either* the default or filesystem encoding. @@ -176,7 +176,7 @@ def fcmp(x, y): # fuzzy comparison function TESTFN_UNICODE_UNENCODEABLE = None else: # Japanese characters (I think - from bug 846133) - TESTFN_UNICODE_UNENCODEABLE = eval('u"@test-\u5171\u6709\u3055\u308c\u308b"') + TESTFN_UNICODE_UNENCODEABLE = eval('u"@test-\\u5171\\u6709\\u3055\\u308c\\u308b"') try: # XXX - Note - should be using TESTFN_ENCODING here - but for # Windows, "mbcs" currently always operates as if in @@ -187,10 +187,9 @@ def fcmp(x, y): # fuzzy comparison function except UnicodeEncodeError: pass else: - print \ - 'WARNING: The filename %r CAN be encoded by the filesystem. ' \ + print('WARNING: The filename %r CAN be encoded by the filesystem. ' \ 'Unicode filename tests may not be effective' \ - % TESTFN_UNICODE_UNENCODEABLE + % TESTFN_UNICODE_UNENCODEABLE) # Make sure we can write to TESTFN, try in /tmp if we can't fp = None @@ -203,8 +202,8 @@ def fcmp(x, y): # fuzzy comparison function TESTFN = TMP_TESTFN del TMP_TESTFN except IOError: - print ('WARNING: tests will fail, unable to write to: %s or %s' % - (TESTFN, TMP_TESTFN)) + print(('WARNING: tests will fail, unable to write to: %s or %s' % + (TESTFN, TMP_TESTFN))) if fp is not None: fp.close() unlink(TESTFN) @@ -246,11 +245,11 @@ def vereq(a, b): """ if not (a == b): - raise TestFailed, "%r == %r" % (a, b) + raise TestFailed("%r == %r" % (a, b)) def sortdict(dict): "Like repr(dict), but in sorted order." - items = dict.items() + items = list(dict.items()) items.sort() reprpairs = ["%r: %r" % pair for pair in items] withcommas = ", ".join(reprpairs) @@ -262,13 +261,13 @@ def check_syntax(statement): except SyntaxError: pass else: - print 'Missing SyntaxError: "%s"' % statement + print('Missing SyntaxError: "%s"' % statement) def open_urlresource(url): - import urllib, urlparse + import urllib.request, urllib.parse, urllib.error, urllib.parse import os.path - filename = urlparse.urlparse(url)[2].split('/')[-1] # '/': it's URL! + filename = urllib.parse.urlparse(url)[2].split('/')[-1] # '/': it's URL! for path in [os.path.curdir, os.path.pardir]: fn = os.path.join(path, filename) @@ -276,8 +275,8 @@ def open_urlresource(url): return open(fn) requires('urlfetch') - print >> get_original_stdout(), '\tfetching %s ...' % url - fn, _ = urllib.urlretrieve(url, filename) + print('\tfetching %s ...' % url, file=get_original_stdout()) + fn, _ = urllib.request.urlretrieve(url, filename) return open(fn) #======================================================================= @@ -311,7 +310,7 @@ def inner(*args, **kwds): finally: if locale and orig_locale: locale.setlocale(category, orig_locale) - inner.func_name = func.func_name + inner.__name__ = func.__name__ inner.__doc__ = func.__doc__ return inner return decorator @@ -329,6 +328,8 @@ def inner(*args, **kwds): class _Dummy: def __getslice__(self, i, j): return j + def __getitem__(self, i): + return i MAX_Py_ssize_t = _Dummy()[:] def set_memlimit(limit): @@ -372,7 +373,7 @@ def wrapper(self): # to make sure they work. We still want to avoid using # too much memory, though, but we do that noisily. maxsize = 5147 - self.failIf(maxsize * memuse + overhead > 20 * _1M) + self.assertFalse(maxsize * memuse + overhead > 20 * _1M) else: maxsize = int((max_memuse - overhead) / memuse) if maxsize < minsize: @@ -481,7 +482,7 @@ def run_doctest(module, verbosity=None): finally: sys.stdout = save_stdout if verbose: - print 'doctest (%s) ... %d tests with zero failures' % (module.__name__, t) + print('doctest (%s) ... %d tests with zero failures' % (module.__name__, t)) return f, t #======================================================================= @@ -498,13 +499,13 @@ def threading_cleanup(num_active, num_limbo): _MAX_COUNT = 10 count = 0 while len(threading._active) != num_active and count < _MAX_COUNT: - print threading._active + print(threading._active) count += 1 time.sleep(0.1) count = 0 while len(threading._limbo) != num_limbo and count < _MAX_COUNT: - print threading._limbo + print(threading._limbo) count += 1 time.sleep(0.1) diff --git a/greentest/test_thread.py b/greentest/test_thread.py index 9db6f7c..9e9d3df 100644 --- a/greentest/test_thread.py +++ b/greentest/test_thread.py @@ -21,10 +21,10 @@ def task(ident): delay = random.random() * numtasks * 0.02 rmutex.release() if verbose: - print 'task', ident, 'will run for', round(delay, 2), 'sec' + print('task', ident, 'will run for', round(delay, 2), 'sec') time.sleep(delay) if verbose: - print 'task', ident, 'done' + print('task', ident, 'done') mutex.acquire() running = running - 1 if running == 0: @@ -37,7 +37,7 @@ def newtask(): mutex.acquire() next_ident = next_ident + 1 if verbose: - print 'creating task', next_ident + print('creating task', next_ident) thread.start_new_thread(task, (next_ident,)) running = running + 1 mutex.release() @@ -45,9 +45,9 @@ def newtask(): for i in range(numtasks): newtask() -print 'waiting for all tasks to complete' +print('waiting for all tasks to complete') done.acquire() -print 'all tasks done' +print('all tasks done') class barrier: def __init__(self, n): @@ -89,13 +89,13 @@ def task2(ident): delay = random.random() * numtasks * 0.02 rmutex.release() if verbose: - print 'task', ident, 'will run for', round(delay, 2), 'sec' + print('task', ident, 'will run for', round(delay, 2), 'sec') time.sleep(delay) if verbose: - print 'task', ident, 'entering barrier', i + print('task', ident, 'entering barrier', i) bar.enter() if verbose: - print 'task', ident, 'leaving barrier', i + print('task', ident, 'leaving barrier', i) mutex.acquire() running -= 1 # Must release mutex before releasing done, else the main thread can @@ -106,25 +106,25 @@ def task2(ident): if finished: done.release() -print '\n*** Barrier Test ***' +print('\n*** Barrier Test ***') if done.acquire(0): - raise ValueError, "'done' should have remained acquired" + raise ValueError("'done' should have remained acquired") bar = barrier(numtasks) running = numtasks for i in range(numtasks): thread.start_new_thread(task2, (i,)) done.acquire() -print 'all tasks done' +print('all tasks done') if hasattr(thread, 'stack_size'): # not all platforms support changing thread stack size - print '\n*** Changing thread stack size ***' + print('\n*** Changing thread stack size ***') if thread.stack_size() != 0: - raise ValueError, "initial stack_size not 0" + raise ValueError("initial stack_size not 0") thread.stack_size(0) if thread.stack_size() != 0: - raise ValueError, "stack_size not reset to default" + raise ValueError("stack_size not reset to default") from os import name as os_name if os_name in ("nt", "os2", "posix"): @@ -133,10 +133,10 @@ def task2(ident): try: thread.stack_size(4096) except ValueError: - print 'caught expected ValueError setting stack_size(4096)' + print('caught expected ValueError setting stack_size(4096)') except thread.error: tss_supported = 0 - print 'platform does not support changing thread stack size' + print('platform does not support changing thread stack size') if tss_supported: failed = lambda s, e: s != e @@ -144,18 +144,18 @@ def task2(ident): for tss in (262144, 0x100000, 0): thread.stack_size(tss) if failed(thread.stack_size(), tss): - raise ValueError, fail_msg % tss - print 'successfully set stack_size(%d)' % tss + raise ValueError(fail_msg % tss) + print('successfully set stack_size(%d)' % tss) for tss in (262144, 0x100000): - print 'trying stack_size = %d' % tss + print('trying stack_size = %d' % tss) next_ident = 0 for i in range(numtasks): newtask() - print 'waiting for all tasks to complete' + print('waiting for all tasks to complete') done.acquire() - print 'all tasks done' + print('all tasks done') # reset stack size to default thread.stack_size(0) diff --git a/greentest/test_thread__boundedsem.py b/greentest/test_thread__boundedsem.py index bc5c0f7..2080e0a 100644 --- a/greentest/test_thread__boundedsem.py +++ b/greentest/test_thread__boundedsem.py @@ -8,4 +8,4 @@ def allocate_lock(): thread.allocate_lock = allocate_lock thread.LockType = coros.BoundedSemaphore -execfile('test_thread.py') +exec(compile(open('test_thread.py').read(), 'test_thread.py', 'exec')) diff --git a/greentest/test_threading.py b/greentest/test_threading.py index ef75e1f..2c61ebb 100644 --- a/greentest/test_threading.py +++ b/greentest/test_threading.py @@ -31,27 +31,27 @@ def __init__(self, name, testcase, sema, mutex, nrunning): def run(self): delay = random.random() * 0.1 if verbose: - print 'task', self.getName(), 'will run for', delay, 'sec' + print('task', self.getName(), 'will run for', delay, 'sec') self.sema.acquire() self.mutex.acquire() self.nrunning.inc() if verbose: - print self.nrunning.get(), 'tasks are running' - self.testcase.assert_(self.nrunning.get() <= 3) + print(self.nrunning.get(), 'tasks are running') + self.testcase.assertTrue(self.nrunning.get() <= 3) self.mutex.release() time.sleep(delay) if verbose: - print 'task', self.getName(), 'done' + print('task', self.getName(), 'done') self.mutex.acquire() self.nrunning.dec() - self.testcase.assert_(self.nrunning.get() >= 0) + self.testcase.assertTrue(self.nrunning.get() >= 0) if verbose: - print self.getName(), 'is finished.', self.nrunning.get(), \ - 'tasks are running' + print(self.getName(), 'is finished.', self.nrunning.get(), \ + 'tasks are running') self.mutex.release() self.sema.release() @@ -78,24 +78,24 @@ def test_various_ops(self): t.start() if verbose: - print 'waiting for all tasks to complete' + print('waiting for all tasks to complete') for t in threads: t.join(NUMTASKS) - self.assert_(not t.isAlive()) + self.assertTrue(not t.isAlive()) if verbose: - print 'all tasks done' + print('all tasks done') self.assertEqual(numrunning.get(), 0) # run with a small(ish) thread stack size (256kB) if hasattr(threading, 'stack_size'): def test_various_ops_small_stack(self): if verbose: - print 'with 256kB thread stack size...' + print('with 256kB thread stack size...') try: threading.stack_size(262144) except thread.error: if verbose: - print 'platform does not support changing thread stack size' + print('platform does not support changing thread stack size') return self.test_various_ops() threading.stack_size(0) @@ -103,12 +103,12 @@ def test_various_ops_small_stack(self): # run with a large thread stack size (1MB) def test_various_ops_large_stack(self): if verbose: - print 'with 1MB thread stack size...' + print('with 1MB thread stack size...') try: threading.stack_size(0x100000) except thread.error: if verbose: - print 'platform does not support changing thread stack size' + print('platform does not support changing thread stack size') return self.test_various_ops() threading.stack_size(0) @@ -128,8 +128,8 @@ def f(mutex): tid = thread.start_new_thread(f, (mutex,)) # Wait for the thread to finish. mutex.acquire() - self.assert_(tid in threading._active) - self.assert_(isinstance(threading._active[tid], + self.assertTrue(tid in threading._active) + self.assertTrue(isinstance(threading._active[tid], threading._DummyThread)) del threading._active[tid] @@ -140,7 +140,7 @@ def test_PyThreadState_SetAsyncExc(self): import ctypes except ImportError: if verbose: - print "test_PyThreadState_SetAsyncExc can't import ctypes" + print("test_PyThreadState_SetAsyncExc can't import ctypes") return # can't do anything set_async_exc = ctypes.pythonapi.PyThreadState_SetAsyncExc @@ -174,21 +174,21 @@ def run(self): t.setDaemon(True) # so if this fails, we don't hang Python at shutdown t.start() if verbose: - print " started worker thread" + print(" started worker thread") # Try a thread id that doesn't make sense. if verbose: - print " trying nonsensical thread id" + print(" trying nonsensical thread id") result = set_async_exc(ctypes.c_long(-1), exception) self.assertEqual(result, 0) # no thread states modified # Now raise an exception in the worker thread. if verbose: - print " waiting for worker thread to get started" + print(" waiting for worker thread to get started") worker_started.wait() if verbose: - print " verifying worker hasn't exited" - self.assert_(not t.finished) + print(" verifying worker hasn't exited") + self.assertTrue(not t.finished) # if verbose: # print " attempting to raise asynch exception in worker" # result = set_async_exc(ctypes.c_long(t.id), exception) @@ -198,7 +198,7 @@ def run(self): # worker_saw_exception.wait(timeout=10) # self.assert_(t.finished) if verbose: - print " all OK(2 disabled) -- joining worker" + print(" all OK(2 disabled) -- joining worker") if t.finished: t.join() # else the thread is still running, and we have no way to kill it @@ -210,7 +210,7 @@ def test_enumerate_after_join(self): old_interval = sys.getcheckinterval() sys.setcheckinterval(1) try: - for i in xrange(1, 1000): + for i in range(1, 1000): t = threading.Thread(target=lambda: None) t.start() t.join() @@ -238,8 +238,8 @@ def joiningfunc(mainthread): rc = p.wait() data = p.stdout.read().replace('\r', '') self.assertEqual(data, "end of main\nend of thread\n") - self.failIf(rc == 2, "interpreter was blocked") - self.failUnless(rc == 0, "Unexpected error") + self.assertFalse(rc == 2, "interpreter was blocked") + self.assertTrue(rc == 0, "Unexpected error") def test_1_join_on_shutdown(self): # The usual case: on exit, wait for a non-daemon thread diff --git a/greentest/test_timeout.py b/greentest/test_timeout.py index 53f1c6d..fc50ac5 100644 --- a/greentest/test_timeout.py +++ b/greentest/test_timeout.py @@ -45,11 +45,11 @@ def testReturnType(self): def testTypeCheck(self): # Test type checking by settimeout() self.sock.settimeout(0) - self.sock.settimeout(0L) + self.sock.settimeout(0) self.sock.settimeout(0.0) self.sock.settimeout(None) self.assertRaises(TypeError, self.sock.settimeout, "") - self.assertRaises(TypeError, self.sock.settimeout, u"") + self.assertRaises(TypeError, self.sock.settimeout, "") self.assertRaises(TypeError, self.sock.settimeout, ()) self.assertRaises(TypeError, self.sock.settimeout, []) self.assertRaises(TypeError, self.sock.settimeout, {}) @@ -58,7 +58,7 @@ def testTypeCheck(self): def testRangeCheck(self): # Test range checking by settimeout() self.assertRaises(ValueError, self.sock.settimeout, -1) - self.assertRaises(ValueError, self.sock.settimeout, -1L) + self.assertRaises(ValueError, self.sock.settimeout, -1) self.assertRaises(ValueError, self.sock.settimeout, -1.0) def testTimeoutThenBlocking(self): @@ -117,12 +117,12 @@ def testConnectTimeout(self): self.addr_remote = ('tut.fi', 80) _t1 = time.time() - self.failUnlessRaises(socket.error, self.sock.connect, + self.assertRaises(socket.error, self.sock.connect, self.addr_remote) _t2 = time.time() _delta = abs(_t1 - _t2) - self.assert_(_delta < _timeout + self.fuzz, + self.assertTrue(_delta < _timeout + self.fuzz, "timeout (%g) is more than %g seconds more than expected (%g)" %(_delta, self.fuzz, _timeout)) @@ -133,11 +133,11 @@ def testRecvTimeout(self): self.sock.settimeout(_timeout) _t1 = time.time() - self.failUnlessRaises(socket.error, self.sock.recv, 1024) + self.assertRaises(socket.error, self.sock.recv, 1024) _t2 = time.time() _delta = abs(_t1 - _t2) - self.assert_(_delta < _timeout + self.fuzz, + self.assertTrue(_delta < _timeout + self.fuzz, "timeout (%g) is %g seconds more than expected (%g)" %(_delta, self.fuzz, _timeout)) @@ -149,11 +149,11 @@ def testAcceptTimeout(self): self.sock.listen(5) _t1 = time.time() - self.failUnlessRaises(socket.error, self.sock.accept) + self.assertRaises(socket.error, self.sock.accept) _t2 = time.time() _delta = abs(_t1 - _t2) - self.assert_(_delta < _timeout + self.fuzz, + self.assertTrue(_delta < _timeout + self.fuzz, "timeout (%g) is %g seconds more than expected (%g)" %(_delta, self.fuzz, _timeout)) @@ -165,11 +165,11 @@ def testRecvfromTimeout(self): self.sock.bind(self.addr_local) _t1 = time.time() - self.failUnlessRaises(socket.error, self.sock.recvfrom, 8192) + self.assertRaises(socket.error, self.sock.recvfrom, 8192) _t2 = time.time() _delta = abs(_t1 - _t2) - self.assert_(_delta < _timeout + self.fuzz, + self.assertTrue(_delta < _timeout + self.fuzz, "timeout (%g) is %g seconds more than expected (%g)" %(_delta, self.fuzz, _timeout)) diff --git a/greentest/test_urllib2.py b/greentest/test_urllib2.py index 52d6e5d..e23caa6 100644 --- a/greentest/test_urllib2.py +++ b/greentest/test_urllib2.py @@ -3,7 +3,7 @@ import os from eventlib.green import socket -import StringIO +import io from eventlib.green import urllib2 from eventlib.green.urllib2 import Request, OpenerDirector @@ -16,7 +16,7 @@ class TrivialTests(unittest.TestCase): def test_trivial(self): # A couple trivial tests - self.assertRaises(ValueError, urllib2.urlopen, 'bogus url') + self.assertRaises(ValueError, urllib.request.urlopen, 'bogus url') # XXX Name hacking to get this to work on Windows. fname = os.path.abspath(urllib2.__file__).replace('\\', '/') @@ -32,7 +32,7 @@ def test_trivial(self): fname = fname.translate(string.maketrans("/.", "./")) file_url = "file://%s" % fname - f = urllib2.urlopen(file_url) + f = urllib.request.urlopen(file_url) buf = f.read() f.close() @@ -43,7 +43,7 @@ def test_parse_http_list(self): ('a, b, "c", "d", "e,f", g, h', ['a', 'b', '"c"', '"d"', '"e,f"', 'g', 'h']), ('a="b\\"c", d="e\\,f", g="h\\\\i"', ['a="b"c"', 'd="e,f"', 'g="h\\i"'])] for string, list in tests: - self.assertEquals(urllib2.parse_http_list(string), list) + self.assertEqual(urllib2.parse_http_list(string), list) def test_request_headers_dict(): @@ -235,11 +235,11 @@ def close(self): pass class MockHeaders(dict): def getheaders(self, name): - return self.values() + return list(self.values()) -class MockResponse(StringIO.StringIO): +class MockResponse(io.StringIO): def __init__(self, code, msg, headers, data, url=None): - StringIO.StringIO.__init__(self, data) + io.StringIO.__init__(self, data) self.code, self.msg, self.headers, self.url = code, msg, headers, url def info(self): return self.headers @@ -292,7 +292,7 @@ def handle(self, fn_name, action, *args, **kwds): res = MockResponse(200, "OK", {}, "") return self.parent.error("http", args[0], res, code, "", {}) elif action == "raise": - raise urllib2.URLError("blah") + raise urllib.error.URLError("blah") assert False def close(self): pass def add_parent(self, parent): @@ -341,7 +341,7 @@ def build_test_opener(*handler_instances): opener.add_handler(h) return opener -class MockHTTPHandler(urllib2.BaseHandler): +class MockHTTPHandler(urllib.request.BaseHandler): # useful for testing redirections and auth # sends supplied headers and code as first response # sends 200 OK as second response @@ -353,12 +353,12 @@ def reset(self): self._count = 0 self.requests = [] def http_open(self, req): - import mimetools, httplib, copy - from StringIO import StringIO + import mimetools, http.client, copy + from io import StringIO self.requests.append(copy.deepcopy(req)) if self._count == 0: self._count = self._count + 1 - name = httplib.responses[self.code] + name = http.client.responses[self.code] msg = mimetools.Message(StringIO(self.headers)) return self.parent.error( "http", req, MockFile(), self.code, name, msg) @@ -396,7 +396,7 @@ def test_badly_named_methods(self): # TypeError in real code; here, returning self from these mock # methods would either cause no exception, or AttributeError. - from urllib2 import URLError + from urllib.error import URLError o = OpenerDirector() meth_spec = [ @@ -404,7 +404,7 @@ def test_badly_named_methods(self): [("redirect_request", "return self")], ] handlers = add_ordered_mock_handlers(o, meth_spec) - o.add_handler(urllib2.UnknownHandler()) + o.add_handler(urllib.request.UnknownHandler()) for scheme in "do", "proxy", "redirect": self.assertRaises(URLError, o.open, scheme+"://example.com/") @@ -462,7 +462,7 @@ def test_raise(self): handlers = add_ordered_mock_handlers(o, meth_spec) req = Request("http://example.com/") - self.assertRaises(urllib2.URLError, o.open, req) + self.assertRaises(urllib.error.URLError, o.open, req) self.assertEqual(o.calls, [(handlers[0], "http_open", (req,), {})]) ## def test_error(self): @@ -520,21 +520,21 @@ def test_processors(self): # *_request self.assertEqual((handler, name), calls[i]) self.assertEqual(len(args), 1) - self.assert_(isinstance(args[0], Request)) + self.assertTrue(isinstance(args[0], Request)) else: # *_response self.assertEqual((handler, name), calls[i]) self.assertEqual(len(args), 2) - self.assert_(isinstance(args[0], Request)) + self.assertTrue(isinstance(args[0], Request)) # response from opener.open is None, because there's no # handler that defines http_open to handle it - self.assert_(args[1] is None or + self.assertTrue(args[1] is None or isinstance(args[1], MockResponse)) def sanepathname2url(path): - import urllib - urlpath = urllib.pathname2url(path) + import urllib.request, urllib.parse, urllib.error + urlpath = urllib.request.pathname2url(path) if os.name == "nt" and urlpath.startswith("///"): urlpath = urlpath[2:] # XXX don't ask me about the mac... @@ -547,9 +547,9 @@ class MockFTPWrapper: def __init__(self, data): self.data = data def retrfile(self, filename, filetype): self.filename, self.filetype = filename, filetype - return StringIO.StringIO(self.data), len(self.data) + return io.StringIO(self.data), len(self.data) - class NullFTPHandler(urllib2.FTPHandler): + class NullFTPHandler(urllib.request.FTPHandler): def __init__(self, data): self.data = data def connect_ftp(self, user, passwd, host, port, dirs): self.user, self.passwd = user, passwd @@ -576,7 +576,7 @@ def connect_ftp(self, user, passwd, host, port, dirs): ]: r = h.ftp_open(Request(url)) # ftp authentication not yet implemented by FTPHandler - self.assert_(h.user == h.passwd == "") + self.assertTrue(h.user == h.passwd == "") self.assertEqual(h.host, socket.gethostbyname(host)) self.assertEqual(h.port, port) self.assertEqual(h.dirs, dirs) @@ -588,7 +588,7 @@ def connect_ftp(self, user, passwd, host, port, dirs): def test_file(self): import rfc822 - h = urllib2.FileHandler() + h = urllib.request.FileHandler() o = h.parent = MockOpener() TESTFN = test_support.TESTFN @@ -645,12 +645,12 @@ def test_file(self): finally: f.close() - self.assertRaises(urllib2.URLError, + self.assertRaises(urllib.error.URLError, h.file_open, Request(url)) finally: os.remove(TESTFN) - h = urllib2.FileHandler() + h = urllib.request.FileHandler() o = h.parent = MockOpener() # XXXX why does // mean ftp (and /// mean not ftp!), and where # is file: scheme specified? I think this is really a bug, and @@ -669,10 +669,10 @@ def test_file(self): try: h.file_open(req) # XXXX remove OSError when bug fixed - except (urllib2.URLError, OSError): - self.assert_(not ftp) + except (urllib.error.URLError, OSError): + self.assertTrue(not ftp) else: - self.assert_(o.req is req) + self.assertTrue(o.req is req) self.assertEqual(req.type, "ftp") def test_http(self): @@ -697,7 +697,7 @@ def set_debuglevel(self, level): def request(self, method, url, body=None, headers={}): self.method = method self.selector = url - self.req_headers += headers.items() + self.req_headers += list(headers.items()) self.req_headers.sort() if body: self.data = body @@ -736,7 +736,7 @@ def getresponse(self): # check socket.error converted to URLError http.raise_on_endheaders = True - self.assertRaises(urllib2.URLError, h.do_open, http, req) + self.assertRaises(urllib.error.URLError, h.do_open, http, req) # check adding of standard headers o.addheaders = [("Spam", "eggs")] @@ -745,8 +745,8 @@ def getresponse(self): r = MockResponse(200, "OK", {}, "") newreq = h.do_request_(req) if data is None: # GET - self.assert_("Content-length" not in req.unredirected_hdrs) - self.assert_("Content-type" not in req.unredirected_hdrs) + self.assertTrue("Content-length" not in req.unredirected_hdrs) + self.assertTrue("Content-type" not in req.unredirected_hdrs) else: # POST self.assertEqual(req.unredirected_hdrs["Content-length"], "0") self.assertEqual(req.unredirected_hdrs["Content-type"], @@ -775,33 +775,33 @@ def test_errors(self): # 200 OK is passed through r = MockResponse(200, "OK", {}, "", url) newr = h.http_response(req, r) - self.assert_(r is newr) - self.assert_(not hasattr(o, "proto")) # o.error not called + self.assertTrue(r is newr) + self.assertTrue(not hasattr(o, "proto")) # o.error not called # anything else calls o.error (and MockOpener returns None, here) r = MockResponse(201, "Created", {}, "", url) - self.assert_(h.http_response(req, r) is None) + self.assertTrue(h.http_response(req, r) is None) self.assertEqual(o.proto, "http") # o.error called self.assertEqual(o.args, (req, r, 201, "Created", {})) def test_cookies(self): cj = MockCookieJar() - h = urllib2.HTTPCookieProcessor(cj) + h = urllib.request.HTTPCookieProcessor(cj) o = h.parent = MockOpener() req = Request("http://example.com/") r = MockResponse(200, "OK", {}, "") newreq = h.http_request(req) - self.assert_(cj.ach_req is req is newreq) - self.assertEquals(req.get_origin_req_host(), "example.com") - self.assert_(not req.is_unverifiable()) + self.assertTrue(cj.ach_req is req is newreq) + self.assertEqual(req.get_origin_req_host(), "example.com") + self.assertTrue(not req.is_unverifiable()) newr = h.http_response(req, r) - self.assert_(cj.ec_req is req) - self.assert_(cj.ec_r is r is newr) + self.assertTrue(cj.ec_req is req) + self.assertTrue(cj.ec_r is r is newr) def test_redirect(self): from_url = "http://example.com/a.html" to_url = "http://example.com/b.html" - h = urllib2.HTTPRedirectHandler() + h = urllib.request.HTTPRedirectHandler() o = h.parent = MockOpener() # ordinary redirect behaviour @@ -814,18 +814,18 @@ def test_redirect(self): try: method(req, MockFile(), code, "Blah", MockHeaders({"location": to_url})) - except urllib2.HTTPError: + except urllib.error.HTTPError: # 307 in response to POST requires user OK - self.assert_(code == 307 and data is not None) + self.assertTrue(code == 307 and data is not None) self.assertEqual(o.req.get_full_url(), to_url) try: self.assertEqual(o.req.get_method(), "GET") except AttributeError: - self.assert_(not o.req.has_data()) + self.assertTrue(not o.req.has_data()) self.assertEqual(o.req.headers["Nonsense"], "viking=withhold") - self.assert_("Spam" not in o.req.headers) - self.assert_("Spam" not in o.req.unredirected_hdrs) + self.assertTrue("Spam" not in o.req.headers) + self.assertTrue("Spam" not in o.req.unredirected_hdrs) # loop detection req = Request(from_url) @@ -842,9 +842,9 @@ def redirect(h, req, url=to_url): while 1: redirect(h, req, "http://example.com/") count = count + 1 - except urllib2.HTTPError: + except urllib.error.HTTPError: # don't stop until max_repeats, because cookies may introduce state - self.assertEqual(count, urllib2.HTTPRedirectHandler.max_repeats) + self.assertEqual(count, urllib.request.HTTPRedirectHandler.max_repeats) # detect endless non-repeating chain of redirects req = Request(from_url, origin_req_host="example.com") @@ -853,30 +853,30 @@ def redirect(h, req, url=to_url): while 1: redirect(h, req, "http://example.com/%d" % count) count = count + 1 - except urllib2.HTTPError: + except urllib.error.HTTPError: self.assertEqual(count, - urllib2.HTTPRedirectHandler.max_redirections) + urllib.request.HTTPRedirectHandler.max_redirections) # don't want to add test_cookielib here def dont_test_cookie_redirect(self): # cookies shouldn't leak into redirected requests - from cookielib import CookieJar + from http.cookiejar import CookieJar from test.test_cookielib import interact_netscape cj = CookieJar() interact_netscape(cj, "http://www.example.com/", "spam=eggs") hh = MockHTTPHandler(302, "Location: http://www.cracker.com/\r\n\r\n") - hdeh = urllib2.HTTPDefaultErrorHandler() - hrh = urllib2.HTTPRedirectHandler() - cp = urllib2.HTTPCookieProcessor(cj) + hdeh = urllib.request.HTTPDefaultErrorHandler() + hrh = urllib.request.HTTPRedirectHandler() + cp = urllib.request.HTTPCookieProcessor(cj) o = build_test_opener(hh, hdeh, hrh, cp) o.open("http://www.example.com/") - self.assert_(not hh.req.has_header("Cookie")) + self.assertTrue(not hh.req.has_header("Cookie")) def test_proxy(self): o = OpenerDirector() - ph = urllib2.ProxyHandler(dict(http="proxy.example.com:3128")) + ph = urllib.request.ProxyHandler(dict(http="proxy.example.com:3128")) o.add_handler(ph) meth_spec = [ [("http_open", "return response")] @@ -894,7 +894,7 @@ def test_proxy(self): def test_basic_auth(self): opener = OpenerDirector() password_manager = MockPasswordManager() - auth_handler = urllib2.HTTPBasicAuthHandler(password_manager) + auth_handler = urllib.request.HTTPBasicAuthHandler(password_manager) realm = "ACME Widget Store" http_handler = MockHTTPHandler( 401, 'WWW-Authenticate: Basic realm="%s"\r\n\r\n' % realm) @@ -908,10 +908,10 @@ def test_basic_auth(self): def test_proxy_basic_auth(self): opener = OpenerDirector() - ph = urllib2.ProxyHandler(dict(http="proxy.example.com:3128")) + ph = urllib.request.ProxyHandler(dict(http="proxy.example.com:3128")) opener.add_handler(ph) password_manager = MockPasswordManager() - auth_handler = urllib2.ProxyBasicAuthHandler(password_manager) + auth_handler = urllib.request.ProxyBasicAuthHandler(password_manager) realm = "ACME Networks" http_handler = MockHTTPHandler( 407, 'Proxy-Authenticate: Basic realm="%s"\r\n\r\n' % realm) @@ -938,15 +938,15 @@ def __init__(self): self.recorded = [] def record(self, info): self.recorded.append(info) - class TestDigestAuthHandler(urllib2.HTTPDigestAuthHandler): + class TestDigestAuthHandler(urllib.request.HTTPDigestAuthHandler): def http_error_401(self, *args, **kwds): self.parent.record("digest") - urllib2.HTTPDigestAuthHandler.http_error_401(self, + urllib.request.HTTPDigestAuthHandler.http_error_401(self, *args, **kwds) - class TestBasicAuthHandler(urllib2.HTTPBasicAuthHandler): + class TestBasicAuthHandler(urllib.request.HTTPBasicAuthHandler): def http_error_401(self, *args, **kwds): self.parent.record("basic") - urllib2.HTTPBasicAuthHandler.http_error_401(self, + urllib.request.HTTPBasicAuthHandler.http_error_401(self, *args, **kwds) opener = RecordingOpenerDirector() @@ -973,7 +973,7 @@ def http_error_401(self, *args, **kwds): def _test_basic_auth(self, opener, auth_handler, auth_header, realm, http_handler, password_manager, request_url, protected_url): - import base64, httplib + import base64, http.client user, password = "wile", "coyote" # .add_password() fed through to password manager @@ -1009,13 +1009,13 @@ def _test_basic_auth(self, opener, auth_handler, auth_header, class MiscTests(unittest.TestCase): def test_build_opener(self): - class MyHTTPHandler(urllib2.HTTPHandler): pass - class FooHandler(urllib2.BaseHandler): + class MyHTTPHandler(urllib.request.HTTPHandler): pass + class FooHandler(urllib.request.BaseHandler): def foo_open(self): pass - class BarHandler(urllib2.BaseHandler): + class BarHandler(urllib.request.BaseHandler): def bar_open(self): pass - build_opener = urllib2.build_opener + build_opener = urllib.request.build_opener o = build_opener(FooHandler, BarHandler) self.opener_has_handler(o, FooHandler) @@ -1033,14 +1033,14 @@ def bar_open(self): pass # a particular case of overriding: default handlers can be passed # in explicitly o = build_opener() - self.opener_has_handler(o, urllib2.HTTPHandler) - o = build_opener(urllib2.HTTPHandler) - self.opener_has_handler(o, urllib2.HTTPHandler) - o = build_opener(urllib2.HTTPHandler()) - self.opener_has_handler(o, urllib2.HTTPHandler) + self.opener_has_handler(o, urllib.request.HTTPHandler) + o = build_opener(urllib.request.HTTPHandler) + self.opener_has_handler(o, urllib.request.HTTPHandler) + o = build_opener(urllib.request.HTTPHandler()) + self.opener_has_handler(o, urllib.request.HTTPHandler) # Issue2670: multiple handlers sharing the same base class - class MyOtherHTTPHandler(urllib2.HTTPHandler): pass + class MyOtherHTTPHandler(urllib.request.HTTPHandler): pass o = build_opener(MyHTTPHandler, MyOtherHTTPHandler) self.opener_has_handler(o, MyHTTPHandler) self.opener_has_handler(o, MyOtherHTTPHandler) @@ -1050,7 +1050,7 @@ def opener_has_handler(self, opener, handler_class): if h.__class__ == handler_class: break else: - self.assert_(False) + self.assertTrue(False) def test_main(verbose=None): diff --git a/greentest/test_urllib2_localnet.py b/greentest/test_urllib2_localnet.py index c298ce2..0423429 100755 --- a/greentest/test_urllib2_localnet.py +++ b/greentest/test_urllib2_localnet.py @@ -1,9 +1,9 @@ -#!/usr/bin/python2 +#!/usr/bin/python3 from greentest import exit_unless_25; exit_unless_25() import sys -import urlparse +import urllib.parse import unittest import hashlib from greentest import test_support @@ -165,13 +165,13 @@ def handle_request(self, request_handler): if len(self._users) == 0: return True - if not request_handler.headers.has_key('Proxy-Authorization'): + if 'Proxy-Authorization' not in request_handler.headers: return self._return_auth_challenge(request_handler) else: auth_dict = self._create_auth_dict( request_handler.headers['Proxy-Authorization'] ) - if self._users.has_key(auth_dict["username"]): + if auth_dict["username"] in self._users: password = self._users[ auth_dict["username"] ] else: return self._return_auth_challenge(request_handler) @@ -214,7 +214,7 @@ def log_message(self, format, *args): pass def do_GET(self): - (scm, netloc, path, params, query, fragment) = urlparse.urlparse( + (scm, netloc, path, params, query, fragment) = urllib.parse.urlparse( self.path, 'http') self.short_path = path if self.digest_auth_handler.handle_request(self): @@ -247,9 +247,9 @@ def setUp(self): self.server.start() self.server.ready.wait() - handler = urllib2.ProxyHandler({"http" : self.PROXY_URL}) - self._digest_auth_handler = urllib2.ProxyDigestAuthHandler() - self.opener = urllib2.build_opener(handler, self._digest_auth_handler) + handler = urllib.request.ProxyHandler({"http" : self.PROXY_URL}) + self._digest_auth_handler = urllib.request.ProxyDigestAuthHandler() + self.opener = urllib.request.build_opener(handler, self._digest_auth_handler) def tearDown(self): self.server.stop() @@ -258,13 +258,13 @@ def test_proxy_with_bad_password_raises_httperror(self): self._digest_auth_handler.add_password(self.REALM, self.URL, self.USER, self.PASSWD+"bad") FakeProxyHandler.digest_auth_handler.set_qop("auth") - self.assertRaises(urllib2.HTTPError, + self.assertRaises(urllib.error.HTTPError, self.opener.open, self.URL) def test_proxy_with_no_password_raises_httperror(self): FakeProxyHandler.digest_auth_handler.set_qop("auth") - self.assertRaises(urllib2.HTTPError, + self.assertRaises(urllib.error.HTTPError, self.opener.open, self.URL) @@ -283,7 +283,7 @@ def test_proxy_qop_auth_int_works_or_throws_urlerror(self): FakeProxyHandler.digest_auth_handler.set_qop("auth-int") try: result = self.opener.open(self.URL) - except urllib2.URLError: + except urllib.error.URLError: # It's okay if we don't support auth-int, but we certainly # shouldn't receive any kind of exception here other than # a URLError. diff --git a/greentest/tpool_test.py b/greentest/tpool_test.py index 39ab4e5..3291582 100644 --- a/greentest/tpool_test.py +++ b/greentest/tpool_test.py @@ -26,7 +26,7 @@ def prnt(msg): if _g_debug: - print msg + print(msg) class yadda(object): def __init__(self): @@ -103,18 +103,18 @@ def key(): def test_wrap_dict(self): my_object = {'a':1} prox = tpool.Proxy(my_object) - self.assertEqual('a', prox.keys()[0]) + self.assertEqual('a', list(prox.keys())[0]) self.assertEqual(1, prox['a']) self.assertEqual(str(my_object), str(prox)) self.assertEqual(repr(my_object), repr(prox)) - self.assertEqual(`my_object`, `prox`) + self.assertEqual(repr(my_object), repr(prox)) def test_wrap_module_class(self): prox = tpool.Proxy(uuid) self.assertEqual(tpool.Proxy, type(prox)) id = prox.uuid4() self.assertEqual(id.get_version(), uuid.uuid4().get_version()) - self.assert_(repr(prox.uuid4)) + self.assertTrue(repr(prox.uuid4)) def test_wrap_eq(self): prox = tpool.Proxy(uuid) @@ -122,14 +122,14 @@ def test_wrap_eq(self): id2 = prox.UUID(str(id1)) self.assertEqual(id1, id2) id3 = prox.uuid4() - self.assert_(id1 != id3) + self.assertTrue(id1 != id3) def test_wrap_nonzero(self): prox = tpool.Proxy(uuid) id1 = prox.uuid4() - self.assert_(bool(id1)) + self.assertTrue(bool(id1)) prox2 = tpool.Proxy([1, 2, 3]) - self.assert_(bool(prox2)) + self.assertTrue(bool(prox2)) def test_multiple_wraps(self): prox1 = tpool.Proxy(uuid) @@ -155,7 +155,7 @@ def nofunc(): self.assertRaises(AttributeError, nofunc) def assertLessThan(self, a, b): - self.assert_(a < b, "%s is not less than %s" % (a, b)) + self.assertTrue(a < b, "%s is not less than %s" % (a, b)) def test_variable_and_keyword_arguments_with_function_calls(self): import optparse @@ -170,9 +170,9 @@ def test_contention(self): pool = coros.CoroutinePool(max_size=4) waiters = [] - waiters.append(pool.execute(lambda: self.assertEquals(prox.one, 1))) - waiters.append(pool.execute(lambda: self.assertEquals(prox.two, 2))) - waiters.append(pool.execute(lambda: self.assertEquals(prox.three, 3))) + waiters.append(pool.execute(lambda: self.assertEqual(prox.one, 1))) + waiters.append(pool.execute(lambda: self.assertEqual(prox.two, 2))) + waiters.append(pool.execute(lambda: self.assertEqual(prox.three, 3))) for waiter in waiters: waiter.wait() @@ -187,14 +187,14 @@ def dont_test_benchmark(self): """ Benchmark computing the amount of overhead tpool adds to function calls. Rename to activate.""" iterations = 10000 def bench(f, *args, **kw): - for i in xrange(iterations): + for i in range(iterations): f(*args, **kw) def noop(): pass normal_results = [] tpool_results = [] - for i in xrange(3): + for i in range(3): start = time.time() bench(noop) end = time.time() @@ -208,8 +208,8 @@ def noop(): avg_normal = sum(normal_results)/len(normal_results) avg_tpool = sum(tpool_results)/len(tpool_results) tpool_overhead = (avg_tpool-avg_normal)/iterations - print "%s iterations\nTpool overhead is %s seconds per call. Normal: %s; Tpool: %s" % ( - iterations, tpool_overhead, normal_results, tpool_results) + print("%s iterations\nTpool overhead is %s seconds per call. Normal: %s; Tpool: %s" % ( + iterations, tpool_overhead, normal_results, tpool_results)) if __name__ == '__main__': diff --git a/greentest/with_eventlet.py b/greentest/with_eventlet.py index cb904e1..567060f 100755 --- a/greentest/with_eventlet.py +++ b/greentest/with_eventlet.py @@ -1,4 +1,4 @@ -#!/usr/bin/python2 +#!/usr/bin/python3 # Copyright (c) 2008-2009 AG Projects # Author: Denis Bilenko @@ -38,7 +38,7 @@ def setup_hub(hub, reactor): from eventlib.api import use_hub try: use_hub(hub) - except ImportError, ex: + except ImportError as ex: # as a shortcut, try to import the reactor with such name try: r = import_reactor(hub) @@ -67,9 +67,9 @@ def parse_args(): setup_hub(hub, reactor) from eventlib.api import get_hub hub = get_hub() # set up the hub now - print '===HUB=%r' % hub + print('===HUB=%r' % hub) if 'twisted.internet.reactor' in sys.modules: - print '===REACTOR=%r' % sys.modules['twisted.internet.reactor'] + print('===REACTOR=%r' % sys.modules['twisted.internet.reactor']) sys.stdout.flush() - execfile(sys.argv[0]) + exec(compile(open(sys.argv[0]).read(), sys.argv[0], 'exec')) diff --git a/greentest/with_timeout.py b/greentest/with_timeout.py index 50539b4..1b471ca 100755 --- a/greentest/with_timeout.py +++ b/greentest/with_timeout.py @@ -1,4 +1,4 @@ -#!/usr/bin/python2 +#!/usr/bin/python3 # Copyright (c) 2008-2009 AG Projects # Author: Denis Bilenko @@ -37,6 +37,7 @@ import os import time import warnings +import tempfile if sys.argv[1:2] and sys.argv[1]=='-t': del sys.argv[1] @@ -53,9 +54,7 @@ try: CURRENT_TEST_FILENAME except NameError: - warnings.filterwarnings('ignore', 'tmpnam is a potential security risk to your program') - CURRENT_TEST_FILENAME = os.tmpnam() - del warnings.filters[0] + CURRENT_TEST_FILENAME = tempfile.NamedTemporaryFile(delete=False).name class Alarm(Exception): pass @@ -68,7 +67,7 @@ def _test(): >>> system('./with_timeout.py -t 3 __init__.py') (0, 0) - >>> system('./with_timeout.py -t 3 /usr/lib/python2.5/BaseHTTPServer.py 0') + >>> system('./with_timeout.py -t 3 /usr/lib/python3.5/BaseHTTPServer.py 0') (7, 3) >>> system('./with_timeout.py -t 3 with_timeout.py --selftest1') @@ -119,7 +118,7 @@ def test_long(self): def execf(): #print 'in execf', disabled_tests def patch_unittest(): - "print test name before it was run and write it pipe" + "print test name before it was run and write it to pipe" import unittest class TestCase(unittest.TestCase): base = unittest.TestCase @@ -131,9 +130,10 @@ def run(self, result=None): name = "%s.%s" % (self.__class__.__name__, testMethodName) if name in disabled_tests: return - print name, ' ' + print(name, ' ') sys.stdout.flush() - file(CURRENT_TEST_FILENAME, 'w').write(name) + print(CURRENT_TEST_FILENAME) + open(CURRENT_TEST_FILENAME, "w").write(name) try: return self.base.run(self, result) finally: @@ -144,7 +144,7 @@ def run(self, result=None): pass unittest.TestCase = TestCase patch_unittest() - execfile(filename, globals()) + exec(compile(open(filename).read(), filename, 'exec'), globals()) while True: #print 'before fork, %s' % disabled_tests @@ -154,9 +154,9 @@ def run(self, result=None): pass child = os.fork() if child == 0: - print '===PYTHON=%s.%s.%s' % sys.version_info[:3] - print '===ARGV=%s' % ' '.join(sys.argv) - print '===TIMEOUT=%r' % TIMEOUT + print('===PYTHON=%s.%s.%s' % sys.version_info[:3]) + print('===ARGV=%s' % ' '.join(sys.argv)) + print('===TIMEOUT=%r' % TIMEOUT) sys.stdout.flush() execf() break @@ -174,20 +174,20 @@ def run(self, result=None): os.kill(child, signal.SIGKILL) except Exception: pass - print '\n===%s was killed after %s seconds' % (child, time.time()-start) + print('\n===%s was killed after %s seconds' % (child, time.time()-start)) sys.stdout.flush() bad_test = None try: - bad_test = file(CURRENT_TEST_FILENAME).read() + bad_test = open(CURRENT_TEST_FILENAME, "rb").read() except IOError: pass if bad_test in disabled_tests: - print '\n===%s was disabled but it still managed to fail?!' % bad_test + print('\n===%s was disabled but it still managed to fail?!' % bad_test) sys.stdout.flush() break if bad_test is None: sys.exit(7) - print '\n===Trying again, now without %s' % bad_test + print('\n===Trying again, now without %s' % bad_test) sys.stdout.flush() disabled_tests.append(bad_test) except: @@ -201,10 +201,10 @@ def run(self, result=None): pass raise else: - print '===%s exited with code %s' % (pid, status) + print('===%s exited with code %s' % (pid, status)) sys.stdout.flush() if disabled_tests: - print '\n===disabled because of timeout: %s\n%s\n' % (len(disabled_tests), '\n'.join(disabled_tests)) + print('\n===disabled because of timeout: %s\n%s\n' % (len(disabled_tests), '\n'.join(disabled_tests))) sys.stdout.flush() if disabled_tests: if status: diff --git a/greentest/wsgi_test.py b/greentest/wsgi_test.py index a9565b3..ae185bc 100644 --- a/greentest/wsgi_test.py +++ b/greentest/wsgi_test.py @@ -30,9 +30,9 @@ from greentest import find_command try: - from cStringIO import StringIO + from io import StringIO except ImportError: - from StringIO import StringIO + from io import StringIO def hello_world(env, start_response): @@ -125,8 +125,8 @@ def test_001_server(self): result = fd.read() fd.close() ## The server responds with the maximum version it supports - self.assert_(result.startswith('HTTP'), result) - self.assert_(result.endswith('hello world')) + self.assertTrue(result.startswith('HTTP'), result) + self.assertTrue(result.endswith('hello world')) def test_002_keepalive(self): sock = api.connect_tcp( @@ -169,7 +169,7 @@ def skip_test_005_run_apachebench(self): # ab is apachebench out = processes.Process(find_command('ab'), ['-c','64','-n','1024', '-k', url]) - print out.read() + print(out.read()) def test_006_reject_long_urls(self): sock = api.connect_tcp( @@ -232,7 +232,7 @@ def test_009_chunked_response(self): fd = sock.makeGreenFile() fd.write('GET / HTTP/1.1\r\nHost: localhost\r\nConnection: close\r\n\r\n') - self.assert_('Transfer-Encoding: chunked' in fd.read()) + self.assertTrue('Transfer-Encoding: chunked' in fd.read()) def test_010_no_chunked_http_1_0(self): self.site.application = chunked_app @@ -241,7 +241,7 @@ def test_010_no_chunked_http_1_0(self): fd = sock.makeGreenFile() fd.write('GET / HTTP/1.0\r\nHost: localhost\r\nConnection: close\r\n\r\n') - self.assert_('Transfer-Encoding: chunked' not in fd.read()) + self.assertTrue('Transfer-Encoding: chunked' not in fd.read()) def test_011_multiple_chunks(self): self.site.application = big_chunks @@ -251,7 +251,7 @@ def test_011_multiple_chunks(self): fd = sock.makeGreenFile() fd.write('GET / HTTP/1.1\r\nHost: localhost\r\nConnection: close\r\n\r\n') headers = fd.readuntil('\r\n\r\n') - self.assert_('Transfer-Encoding: chunked' in headers) + self.assertTrue('Transfer-Encoding: chunked' in headers) chunks = 0 chunklen = int(fd.readline(), 16) while chunklen: @@ -259,7 +259,7 @@ def test_011_multiple_chunks(self): chunk = fd.read(chunklen) fd.readline() chunklen = int(fd.readline(), 16) - self.assert_(chunks > 1) + self.assertTrue(chunks > 1) def test_012_ssl_server(self): from eventlib import httpc @@ -275,7 +275,7 @@ def wsgi_app(environ, start_response): api.spawn(wsgi.server, sock, wsgi_app) result = httpc.post("https://localhost:4201/foo", "abc") - self.assertEquals(result, 'abc') + self.assertEqual(result, 'abc') def test_013_empty_return(self): from eventlib import httpc @@ -289,7 +289,7 @@ def wsgi_app(environ, start_response): api.spawn(wsgi.server, sock, wsgi_app) res = httpc.get("https://localhost:4202/foo") - self.assertEquals(res, '') + self.assertEqual(res, '') if __name__ == '__main__': diff --git a/setup.py b/setup.py index 3775bf3..624fd25 100755 --- a/setup.py +++ b/setup.py @@ -1,4 +1,4 @@ -#!/usr/bin/python2 +#!/usr/bin/python3 import os From 69f5e172925ca5d32f01ba8267f4c43d4f180cde Mon Sep 17 00:00:00 2001 From: Petar Bozin Date: Thu, 14 Jan 2021 00:42:05 +0100 Subject: [PATCH 2/2] Added utf-8 encoding of results --- eventlib/green/httplib.py | 2 +- eventlib/green/urllib.py | 4 ++-- eventlib/green/urllib2.py | 22 ++++++++++++---------- eventlib/greenio.py | 8 ++++---- eventlib/twistedutil/protocol.py | 12 ++++++------ eventlib/twistedutil/protocols/basic.py | 2 +- eventlib/wsgi.py | 4 ++-- examples/twisted_client.py | 2 +- 8 files changed, 29 insertions(+), 27 deletions(-) diff --git a/eventlib/green/httplib.py b/eventlib/green/httplib.py index e3beee1..b6eb4a8 100644 --- a/eventlib/green/httplib.py +++ b/eventlib/green/httplib.py @@ -1092,7 +1092,7 @@ def send(self, stuff, flags = 0): sendall = send def recv(self, len = 1024, flags = 0): - return self._ssl.read(len) + return self._ssl.read(len).decode('utf-8') def __getattr__(self, attr): return getattr(self._sock, attr) diff --git a/eventlib/green/urllib.py b/eventlib/green/urllib.py index 924b079..80bf63c 100644 --- a/eventlib/green/urllib.py +++ b/eventlib/green/urllib.py @@ -5,8 +5,8 @@ from urllib.error import( __all__ ) from urllib.response import( __all__ ) from urllib.robotparser import( __all__ ) -from urllib.request import( __all__, __version__, MAXFTPCACHE, ftpcache, ftpwrapper, _noheaders, noheaders, proxy_bypass ) -from urllib.parse import( __all__, splithost, splituser, splittype, splitattr, splitpasswd, splitport, splitquery, splitvalue) +from urllib.request import( __all__, __version__, MAXFTPCACHE, addinfourl, ftpcache, ftpwrapper, _noheaders, noheaders, proxy_bypass, url2pathname, getproxies ) +from urllib.parse import( __all__, unwrap, unquote, quote, splithost, splituser, splittype, splitattr, splitpasswd, splitport, splitquery, splitvalue) from urllib.parse import urljoin as basejoin parse = urllib.parse.parse_qs diff --git a/eventlib/green/urllib2.py b/eventlib/green/urllib2.py index 11a27c8..2e9276b 100644 --- a/eventlib/green/urllib2.py +++ b/eventlib/green/urllib2.py @@ -1,19 +1,19 @@ -urllib2 = __import__('urllib2') -for var in dir(urllib2): - exec("%s = urllib2.%s" % (var, var)) +urllib3 = __import__('urllib3') +for var in dir(urllib3): + exec("%s = urllib3.%s" % (var, var)) # import the following to be a better drop-in replacement __import_lst = ['__version__', '__cut_port_re', '_parse_proxy'] for var in __import_lst: - exec("%s = getattr(urllib2, %r, None)" % (var, var)) + exec("%s = getattr(urllib3, %r, None)" % (var, var)) for x in ('urlopen', 'install_opener', 'build_opener', 'HTTPHandler', 'HTTPSHandler', 'HTTPCookieProcessor', 'FileHandler', 'FTPHandler', 'CacheFTPHandler', 'GopherError'): globals().pop(x, None) from eventlib.green import httplib -import mimetools +from email import message_from_string as Message import os from eventlib.green import socket import sys @@ -24,6 +24,8 @@ except ImportError: from io import StringIO +import urllib.request + from eventlib.green.urllib import (unwrap, unquote, splittype, splithost, quote, addinfourl, splitport, splitquery, splitattr, ftpwrapper, noheaders, splituser, splitpasswd, splitvalue) @@ -78,9 +80,9 @@ class HTTPHandler(urllib.request.HTTPHandler): def http_open(self, req): return self.do_open(httplib.HTTPConnection, req) - http_request = AbstractHTTPHandler.do_request_ + http_request = urllib.request.AbstractHTTPHandler.do_request_ -if hasattr(urllib2, 'HTTPSHandler'): +if hasattr(urllib3, 'HTTPSHandler'): class HTTPSHandler(urllib.request.HTTPSHandler): def https_open(self, req): @@ -116,7 +118,7 @@ def open_local_file(self, req): size = stats.st_size modified = email.Utils.formatdate(stats.st_mtime, usegmt=True) mtype = mimetypes.guess_type(file)[0] - headers = mimetools.Message(StringIO( + headers = Message(StringIO( 'Content-type: %s\nContent-length: %d\nLast-modified: %s\n' % (mtype or 'text/plain', size, modified))) if host: @@ -176,7 +178,7 @@ def ftp_open(self, req): if retrlen is not None and retrlen >= 0: headers += "Content-length: %d\n" % retrlen sf = StringIO(headers) - headers = mimetools.Message(sf) + headers = Message(sf) return addinfourl(fp, headers, req.get_full_url()) except ftplib.all_errors as msg: raise IOError('ftp error', msg).with_traceback(sys.exc_info()[2]) @@ -232,7 +234,7 @@ def check_cache(self): break self.soonest = min(self.timeout.values()) -class GopherHandler(BaseHandler): +class GopherHandler(urllib.request.BaseHandler): def gopher_open(self, req): # XXX can raise socket.error from eventlib.green import gopherlib # this raises DeprecationWarning in 2.5 diff --git a/eventlib/greenio.py b/eventlib/greenio.py index e762592..5922b27 100644 --- a/eventlib/greenio.py +++ b/eventlib/greenio.py @@ -57,7 +57,7 @@ def recv(self, buflen): raise except socket.error as e: if e[0] == errno.EPIPE: - _bytes = b'' + _bytes = '' else: raise else: @@ -122,7 +122,7 @@ def socket_send(descriptor, data:bytes): SOCKET_CLOSED = (errno.ECONNRESET, errno.ENOTCONN, errno.ESHUTDOWN) def socket_recv(descriptor, buflen): try: - return descriptor.recv(buflen) + return descriptor.recv(buflen).decode('utf-8') except socket.error as e: if e.args[0] in BLOCKING_ERR: return None @@ -189,7 +189,7 @@ def __init__(self, family_or_realsock=socket.AF_INET, *args, **kwargs): self._fileno = fd.fileno() self.sendcount = 0 self.recvcount = 0 - self.recvbuffer = b'' + self.recvbuffer = '' self.closed = False self.timeout = socket.getdefaulttimeout() @@ -472,7 +472,7 @@ def readuntil(self, terminator, size=None): chunk, self.sock.recvbuffer = buf[:found], buf[found:] return chunk checked = len(buf) - d = self.sock.recv(BUFFER_SIZE) + d = self.sock.recv(BUFFER_SIZE).encode('utf-8') if not d: break buf += d diff --git a/eventlib/twistedutil/protocol.py b/eventlib/twistedutil/protocol.py index 61abe1b..bcd0dbc 100644 --- a/eventlib/twistedutil/protocol.py +++ b/eventlib/twistedutil/protocol.py @@ -208,7 +208,7 @@ def recv(self): if self._disconnected_event.ready(): return '' try: - return self._wait() + return self._wait().decode("utf-8") except ConnectionDone: return '' @@ -242,7 +242,7 @@ def __next__(self): class GreenTransport(GreenTransportBase): protocol_class = Protocol - _buffer = b'' + _buffer = '' _error = None def read(self, size=-1): @@ -250,7 +250,7 @@ def read(self, size=-1): if not self._disconnected_event.ready(): try: while len(self._buffer) < size or size < 0: - self._buffer += self._wait() + self._buffer += self._wait().decode('utf-8') except ConnectionDone: pass except: @@ -259,7 +259,7 @@ def read(self, size=-1): if size>=0: result, self._buffer = self._buffer[:size], self._buffer[size:] else: - result, self._buffer = self._buffer, b'' + result, self._buffer = self._buffer, '' if not result and self._disconnected_event.has_exception(): try: self._disconnected_event.wait() @@ -273,7 +273,7 @@ def recv(self, buflen=None): self.resumeProducing() try: try: - recvd = self._wait() + recvd = self._wait().decode('utf-8') #print 'received %r' % recvd self._buffer += recvd except ConnectionDone: @@ -284,7 +284,7 @@ def recv(self, buflen=None): finally: self.pauseProducing() if buflen is None: - result, self._buffer = self._buffer, b'' + result, self._buffer = self._buffer, '' else: result, self._buffer = self._buffer[:buflen], self._buffer[buflen:] if not result and self._disconnected_event.has_exception(): diff --git a/eventlib/twistedutil/protocols/basic.py b/eventlib/twistedutil/protocols/basic.py index 39d16be..34b4c50 100644 --- a/eventlib/twistedutil/protocols/basic.py +++ b/eventlib/twistedutil/protocols/basic.py @@ -44,7 +44,7 @@ class LineOnlyReceiverTransport(GreenTransportBase): protocol_class = LineOnlyReceiver def readline(self): - return self._wait() + return self._wait().decode('utf-8') def sendline(self, line): self.protocol.sendLine(line) diff --git a/eventlib/wsgi.py b/eventlib/wsgi.py index 108cd3c..27603e9 100644 --- a/eventlib/wsgi.py +++ b/eventlib/wsgi.py @@ -187,11 +187,11 @@ def write(data, _writelines=wfile.writelines): if use_chunked: ## Write the chunked encoding - towrite.append("%x\r\n%s\r\n" % (len(data), data)) + towrite.append("%x\r\n%s\r\n" % len(data), data) else: towrite.append(data) try: - _writelines(towrite) + _writelines(x.encode() for x in towrite) length[0] = length[0] + sum(map(len, towrite)) except UnicodeEncodeError: print("Encountered unicode while attempting to write wsgi response: ", [x for x in towrite if isinstance(x, str)]) diff --git a/examples/twisted_client.py b/examples/twisted_client.py index e0c3886..d83cb83 100644 --- a/examples/twisted_client.py +++ b/examples/twisted_client.py @@ -15,7 +15,7 @@ conn = GreenClientCreator(reactor).connectTCP('www.google.com', 80) conn.write('GET /not_found HTTP/1.0\r\n\r\n') conn.loseWriteConnection() -print(conn.read().decode('utf-8')) +print(conn.read()) print("\n\nRead from SSL connection line by line\n\n")