remove unused imports and trailing spaces.

methane · methane · commit 88fe146d4950 · 2013-01-31T02:09:04.000+09:00
diff --git a/ws4py/framing.py b/ws4py/framing.py
@@ -1,6 +1,4 @@
 # -*- coding: utf-8 -*-
-import array
-import os
 from struct import pack, unpack
 
 from ws4py.exc import FrameTooLargeException, ProtocolException
@@ -257,7 +255,7 @@ def mask(self, data):
         Performs the masking or unmasking operation on data
         using the simple masking algorithm:
 
-        .. 
+        ..
            j                   = i MOD 4
            transformed-octet-i = original-octet-i XOR masking-key-octet-j
 
diff --git a/ws4py/messaging.py b/ws4py/messaging.py
@@ -1,7 +1,6 @@
 # -*- coding: utf-8 -*-
 import os
 import struct
-import copy
 
 from ws4py.framing import Frame, OPCODE_CONTINUATION, OPCODE_TEXT, \
      OPCODE_BINARY, OPCODE_CLOSE, OPCODE_PING, OPCODE_PONG
diff --git a/ws4py/server/cherrypyserver.py b/ws4py/server/cherrypyserver.py
@@ -61,11 +61,9 @@ def ws(self):
 meaning you could also dynamically change the class based
 on other envrionmental settings (is the user authenticated for ex).
 """
-import sys
 import base64
 from hashlib import sha1
 import inspect
-import socket
 import threading
 
 import cherrypy
diff --git a/ws4py/server/geventserver.py b/ws4py/server/geventserver.py
@@ -10,45 +10,45 @@
 
 class UpgradableWSGIHandler(gevent.pywsgi.WSGIHandler):
     """Upgradable version of gevent.pywsgi.WSGIHandler class
-    
+
     This is a drop-in replacement for gevent.pywsgi.WSGIHandler that supports
     protocol upgrades via WSGI environment. This means you can create upgraders
     as WSGI apps or WSGI middleware.
-    
+
     If an HTTP request comes in that includes the Upgrade header, it will add
     to the environment two items:
-    
+
     ``upgrade.protocol``
       The protocol to upgrade to. Checking for this lets you know the request
-      wants to be upgraded and the WSGI server supports this interface. 
-    
+      wants to be upgraded and the WSGI server supports this interface.
+
     ``upgrade.socket``
       The raw Python socket object for the connection. From this you can do any
       upgrade negotiation and hand it off to the proper protocol handler.
-    
+
     The upgrade must be signalled by starting a response using the 101 status
     code. This will inform the server to flush the headers and response status
-    immediately, not to expect the normal WSGI app return value, and not to 
-    look for more HTTP requests on this connection. 
-    
+    immediately, not to expect the normal WSGI app return value, and not to
+    look for more HTTP requests on this connection.
+
     To use this handler with gevent.pywsgi.WSGIServer, you can pass it to the
     constructor:
-    
+
     .. code-block:: python
        :linenos:
 
-       server = WSGIServer(('127.0.0.1', 80), app, 
+       server = WSGIServer(('127.0.0.1', 80), app,
                            handler_class=UpgradableWSGIHandler)
-    
-    Alternatively, you can specify it as a class variable for a WSGIServer 
+
+    Alternatively, you can specify it as a class variable for a WSGIServer
     subclass:
-    
+
     .. code-block:: python
        :linenos:
 
        class UpgradableWSGIServer(gevent.pywsgi.WSGIServer):
              handler_class = UpgradableWSGIHandler
-    
+
     """
     def run_application(self):
         upgrade_header = self.environ.get('HTTP_UPGRADE', '').lower()
@@ -65,12 +65,12 @@ def start_response_for_upgrade(status, headers, exc_info=None):
                         sline = '%s %s\r\n' % (self.request_version, self.status)
                         write(sline)
                         self.response_length += len(sline)
-                        
+
                         for header in headers:
                             hline = '%s: %s\r\n' % header
                             write(hline)
                             self.response_length += len(hline)
-                            
+
                         write('\r\n')
                         self.response_length += 2
                     else:
@@ -93,17 +93,17 @@ def start_response_for_upgrade(status, headers, exc_info=None):
 
 class WebSocketServer(gevent.pywsgi.WSGIServer):
     handler_class = UpgradableWSGIHandler
-    
+
     def __init__(self, address, *args, **kwargs):
         protocols = kwargs.pop('websocket_protocols', [])
         extensions = kwargs.pop('websocket_extensions', [])
         websocket = kwargs.pop('websocket_class', WebSocket)
-        
+
         gevent.pywsgi.WSGIServer.__init__(self, address, *args, **kwargs)
         self.application = WebSocketUpgradeMiddleware(app=self.handler,
                                                       protocols=protocols,
                                                       extensions=extensions,
-                                                      websocket_class=websocket)    
+                                                      websocket_class=websocket)
 
     def handler(self, websocket):
         g = gevent.spawn(websocket.run)
@@ -112,7 +112,6 @@ def handler(self, websocket):
 
 if __name__ == '__main__':
     import logging
-    import sys
     logging.basicConfig(format='%(asctime)s %(message)s')
     logger = logging.getLogger()
     logger.setLevel(logging.DEBUG)
@@ -123,4 +122,3 @@ def handler(self, websocket):
     from ws4py.websocket import EchoWebSocket
     server = WebSocketServer(('127.0.0.1', 9001), websocket_class=EchoWebSocket)
     server.serve_forever()
-        
diff --git a/ws4py/server/wsgi/middleware.py b/ws4py/server/wsgi/middleware.py
@@ -1,18 +1,14 @@
 # -*- coding: utf-8 -*-
-import copy
 import base64
 from hashlib import sha1
-import types
-import socket
 
 from ws4py import WS_KEY, WS_VERSION
-from ws4py.exc import HandshakeError, StreamClosed
-from ws4py.streaming import Stream
+from ws4py.exc import HandshakeError
 from ws4py.websocket import WebSocket
 
 class WebSocketUpgradeMiddleware(object):
     def __init__(self, app, fallback_app=None, protocols=None, extensions=None,
-                    websocket_class=WebSocket, versions=WS_VERSION):
+                 websocket_class=WebSocket, versions=WS_VERSION):
         """
         WSGI middleware that performs the WebSocket upgrade handshake.
 
@@ -23,7 +19,7 @@ def ws_handler(websocket):
               ...
 
            app = WebSocketUpgradeMiddleware(ws_handler)
-        
+
 
         If the handshake succeeds, it calls ``app`` with an instance of
         ``websocket_class`` with a copy of the environ dictionary.
@@ -49,31 +45,31 @@ def ws_handler(websocket):
         self.websocket_class = websocket_class
         self.versions = versions
         self.supported_versions = ', '.join([str(v) for v in versions])
-    
-    def __call__(self, environ, start_response):  
+
+    def __call__(self, environ, start_response):
         # Initial handshake validation
         try:
             if 'websocket' not in environ.get('upgrade.protocol', environ.get('HTTP_UPGRADE', '')).lower():
                 raise HandshakeError("Upgrade protocol is not websocket")
-            
+
             if environ.get('REQUEST_METHOD') != 'GET':
                 raise HandshakeError('Method is not GET')
-            
+
             key = environ.get('HTTP_SEC_WEBSOCKET_KEY')
             if key:
                 ws_key = base64.b64decode(key)
                 if len(ws_key) != 16:
                     raise HandshakeError("WebSocket key's length is invalid")
             else:
                 raise HandshakeError("Not a valid HyBi WebSocket request")
-            
+
             version = environ.get('HTTP_SEC_WEBSOCKET_VERSION')
             version_is_valid = False
             if version:
                 try: version = int(version)
                 except: pass
                 else: version_is_valid = version in self.versions
-                        
+
             if not version_is_valid:
                 raise HandshakeError('Unsupported WebSocket version: %s' % version)
 
@@ -85,7 +81,7 @@ def __call__(self, environ, start_response):
                 start_response("400 Bad Handshake",
                                [('Sec-WebSocket-Version', self.supported_versions)])
                 return [str(e)]
-        
+
         # Collect supported subprotocols
         protocols = self.protocols or []
         subprotocols = environ.get('HTTP_SEC_WEBSOCKET_PROTOCOL')
@@ -105,7 +101,7 @@ def __call__(self, environ, start_response):
                 ext = ext.strip()
                 if ext in exts:
                     ws_extensions.append(ext)
-        
+
         # Build and start the HTTP response
         headers = [
             ('Upgrade', 'websocket'),
@@ -117,14 +113,14 @@ def __call__(self, environ, start_response):
             headers.append(('Sec-WebSocket-Protocol', ', '.join(ws_protocols)))
         if ws_extensions:
             headers.append(('Sec-WebSocket-Extensions', ','.join(ws_extensions)))
-        
+
         start_response("101 Web Socket Hybi Handshake", headers)
 
         if 'upgrade.socket' in environ:
             upgrade_socket = environ['upgrade.socket']
         else:
             upgrade_socket = environ['wsgi.input']._sock
-            
+
         return self.app(self.websocket_class(upgrade_socket,
                                              ws_protocols,
                                              ws_extensions,
diff --git a/ws4py/websocket.py b/ws4py/websocket.py
@@ -1,12 +1,6 @@
 # -*- coding: utf-8 -*-
-import base64
-import copy
-import errno
-import logging
 import socket
-from sys import exc_info
 import time
-import traceback
 import threading
 import types
 
