Apply more linting fixes to the files

wolfy1339 · wolfy1339 · commit 64e83eb47a69 · 2016-10-06T17:29:56.000-04:00
diff --git a/zirc/caps.py b/zirc/caps.py
@@ -11,8 +11,8 @@ def __init__(self, *args):
                 self.stringcaps.append(cap.name)
             else:
                 self.stringcaps.append(cap)
-                
-    def handler(self,event):
+
+    def handler(self, event):
         if event.arguments[0] == "LS":
             servcaps = event.arguments[1].split(' ')
             for c in servcaps:
@@ -21,16 +21,15 @@ def handler(self,event):
             if not self.availablecaps:
                 self.bot.send("CAP END")
             else:
-                self.bot.send("CAP REQ :"+" ".join(self.availablecaps))
+                self.bot.send("CAP REQ :" + " ".join(self.availablecaps))
         elif event.arguments[0] == "ACK":
             for cap in self.caps:
                 if hasattr(cap, "run"):
                     cap.run(self.bot)
 
     def run(self, bot):
         self.bot = bot
-        self.bot.listen(self.handler,"cap")
+        self.bot.listen(self.handler, "cap")
         self.bot.send("CAP LS")
-        
 
-    __call__ = run
+    __call__ = run
diff --git a/zirc/client.py b/zirc/client.py
@@ -8,74 +8,79 @@
 
 class Client(object):
     listeners = []
-    def connect(self, config_class = None):
+
+    def connect(self, config_class=None):
 
         self.fp = floodProtect()
         if not hasattr(self, "connection"):
             raise NoSocket("{0} has no attribute 'connection'".format(self))
         if config_class is None:
             raise NoConfig("config_class not a argument when calling connect")
-            
+
         self._config = config_class
         self.socket = self.connection((self._config["host"], self._config["port"]))
 
         self._config["caps"](self)
 
         if self._config.get("password"):
             self.send("PASS {0}".format(self._config["password"]))
-        
+
         self.send("NICK {0}".format(self._config["nickname"]))
         self.send("USER {0} * * :{1}".format(self._config["ident"], self._config["realname"]))
-        
+
         self._channels = self._config["channels"]
         self.loop = EventLoop(self.recv)
+
     def recv(self):
-        self.buffer= ""
+        self.buffer = ""
         while not self.buffer.endswith("\r\n"):
             self.buffer += self.socket.recv(2048).decode("utf-8", errors="replace")
         self.buffer = self.buffer.strip().split("\r\n")
         return self.buffer
+
     def send(self, data):
         if hasattr(self, "on_send"):
             self.on_send(data)
         self.fp.queue_add(self.socket, "{0}\r\n".format(data).encode("UTF-8"))
+
     def start(self):
         self.loop.create_job("main", self.main_job)
         self.loop.run()
+
     def main_job(self, event):
         """loop job to provide a event based system for clients."""
         args = {"event": event, "bot": self, "irc": connection_wrapper(self), "args": " ".join(event.arguments).split(" ")[1:]}
-        
-        #add arguments from event, for easier access
+
+        # add arguments from event, for easier access
         args.update({k: getattr(event, k) for k in dir(event) if not k.startswith("__") and not k.endswith("__")})
-    
+
         if event.type == "001":
             for channel in self._channels:
                 self.send("JOIN {0}".format(channel))
 
         to_call = []
-        
+
         if hasattr(self, "on_all"):
             to_call.append(self.on_all)
-        
-        if hasattr(self, "on_"+event.type.lower()):
-            to_call.append(getattr(self, "on_"+event.type.lower()))
-        
+
+        if hasattr(self, "on_" + event.type.lower()):
+            to_call.append(getattr(self, "on_" + event.type.lower()))
+
         if event.type != event.text_type:
-            if hasattr(self, "on_"+event.text_type.lower()):
-                to_call.append(getattr(self, "on_"+event.text_type.lower()))
+            if hasattr(self, "on_" + event.text_type.lower()):
+                to_call.append(getattr(self, "on_" + event.text_type.lower()))
 
         for event_name, func in self.listeners:
             if event_name == event.text_type.lower() or event_name == event.type.lower():
                 to_call.append(func)
-        #Call the functions here
+        # Call the functions here
         for call_func in to_call:
             util.function_argument_call(call_func, args)()
-    
+
         if event.type == "PING":
             self.send("PONG :{0}".format(" ".join(event.arguments)))
-    
-        #CTCP Replies
+
+        # CTCP Replies
         if event.type == "PRIVMSG" and " ".join(event.arguments).startswith("\x01") and hasattr(self, "ctcp"):
             ctcp_message = " ".join(event.arguments).replace("\x01", "").upper()
             if ctcp_message in self.ctcp.keys():
@@ -84,16 +89,19 @@ def main_job(self, event):
                 else:
                     result = self.ctcp[ctcp_message]
                 self.send("NOTICE {0} :{1} {2}".format(event.source.nick, ctcp_message, result))
-    #Basic client use
+
+    # Basic client use
     def privmsg(self, channel, message):
         MSGLEN = 400 - len("PRIVMSG {} :\r\n".format(channel).encode())
-        strings = [message[i:i+MSGLEN] for i in range(0, len(message), MSGLEN)]
+        strings = [message[i:i + MSGLEN] for i in range(0, len(message), MSGLEN)]
         for message in strings:
             self.send("PRIVMSG {0} :{1}".format(channel, message))
+
     def reply(self, event, message):
         if event.target == self._config['nickname']:
             self.privmsg(event.source.nick, message)
         else:
             self.privmsg(event.target, message)
+
     def listen(self, func, event_name):
         self.listeners.append((event_name.lower(), func))
diff --git a/zirc/config.py b/zirc/config.py
@@ -3,7 +3,7 @@
 class IRCConfig(object):
     """
     Class for holding zIRC config infomation.
-    
+
     >>> self.config = zirc.IRCConfig(nickname="IRCConfigTest")
     >>> self.connect(self.config)
     """
@@ -15,7 +15,7 @@ def __init__(self, **c):
                   "realname": "zIRC Bot",
                   "channels": ["#zirc"],
                   "caps": Caps()
-                  }
+        }
         self.dict.update(c)
 
     def sterilise(self, method):
diff --git a/zirc/connection.py b/zirc/connection.py
@@ -5,7 +5,7 @@
 class Socket(object):
     """
     A class for creating socket connections.
-    
+
     Creating a connection:
         address = ("irc.stuxnet.xyz", 6697)
         Socket(wrapper=ssl.wrap_socket, family=socket.AF_INET6)(address)
@@ -17,11 +17,12 @@ def __init__(self, wrapper=same, family=socket.AF_INET, socket_class=None, bind_
             self.sock = socket.socket(family, socket.SOCK_STREAM)
         self.bind_address = bind_address
         self.wrapper = wrapper
+
     def connect(self, socket_address):
         self.sock = self.wrapper(self.sock)
         if self.bind_address:
             self.sock.bind(self.bind_address)
         self.sock.connect(socket_address)
-        
+
         return self.sock
     __call__ = connect
diff --git a/zirc/errors.py b/zirc/errors.py
@@ -1,5 +1,5 @@
 import sys as _sys
-if _sys.version_info > (2,7):
+if _sys.version_info > (2, 7):
     class ConnectionError(OSError):
         pass
 
@@ -16,9 +16,9 @@ class NoConfig(IRCError):
     pass
 
 
-#test.py
+# test.py
 class TestError(Exception):
     pass
 
 class InvalidLine(TestError):
-    pass
+    pass
diff --git a/zirc/event.py b/zirc/event.py
@@ -19,7 +19,7 @@ def __init__(self, raw):
             self.type, args = raw.split(" ", 1)
             self.source = self.target = None
         if self.target:
-            if self.target.startswith(":"): # n!u@h NICK :nuh
+            if self.target.startswith(":"):  # n!u@h NICK :nuh
                 self.target = self.target.replace(":", "", 1)
         self.arguments = []
         if args.startswith(":"):
@@ -31,7 +31,7 @@ def __init__(self, raw):
                 self.arguments.append(arg)
         if len(args) > 1:
             self.arguments.append(args[1])
-    
+
         self.text_type = irc_events.get(self.type, self.type).upper()
 
     def __str__(self):
diff --git a/zirc/ext/fifo.py b/zirc/ext/fifo.py
@@ -8,7 +8,7 @@ def fifo_while(send_function, name):
             line = f.readline()[:-1]
             if len(line) > 0:
                 send_function(line)
-                
+
 def Fifo(send_function, name="fifo"):
     thread = threading.Thread(target=fifo_while, args=(send_function, name))
     thread.daemon = True
diff --git a/zirc/ext/proxy.py b/zirc/ext/proxy.py
@@ -8,8 +8,10 @@ def __init__(self, host="localhost", port=1080, protocol=socks.SOCKS5):
         self.host = host
         self.port = port
         self.protocol = protocol
+
     def __repr__(self):
         return "Proxy({0}, {1})".format(self.host, self.protocol)
+
     def __call__(self, family=socket.AF_INET, type=socket.SOCK_STREAM):
         socks.socksocket.__init__(self, family, type)
         self.set_proxy(self.protocol, self.host, self.port)
diff --git a/zirc/ext/sasl.py b/zirc/ext/sasl.py
@@ -5,27 +5,29 @@
 
 class Sasl(object):
     name = "sasl"
+
     def __init__(self, username, password, method="plain"):
         self.username = username
         self.password = password
         self.method = method
+
     def run(self, bot):
         self.bot = bot
-        bot.listen(self.on_authenticate,"authenticate")
-        bot.listen(self.on_saslfailed,"saslfailed")
-        bot.listen(self.on_saslsuccess,"saslsuccess")
+        bot.listen(self.on_authenticate, "authenticate")
+        bot.listen(self.on_saslfailed, "saslfailed")
+        bot.listen(self.on_saslsuccess, "saslsuccess")
         if self.method == "plain":
             bot.send("AUTHENTICATE PLAIN")
         else:
             raise SASLError("not implemented yet")
-    
-    def on_authenticate(self,event):
+
+    def on_authenticate(self, event):
         if event.arguments[0] == "+":
             password = base64.b64encode("{0}\x00{0}\x00{1}".format(self.username, self.password).encode("UTF-8")).decode("UTF-8")
             self.bot.send("AUTHENTICATE {0}".format(password))
 
     def on_saslfailed(self, event):
-        raise SASLError("SASL authentication failed!") # do something else later, like try another method
+        raise SASLError("SASL authentication failed!")  # do something else later, like try another method
 
     def on_saslsuccess(self, event):
         self.bot.send("CAP END")
diff --git a/zirc/flood.py b/zirc/flood.py
@@ -28,7 +28,7 @@ def queue_add(self, connection, raw):
             self.queuet.start()
 
     def queue_add_first(self, connection, raw):
-        self.irc_queue=[[connection,raw]]+self.irc_queue
+        self.irc_queue = [[connection, raw]] + self.irc_queue
         if not self.irc_queue_running:
             self.irc_queue_running = True
             self.queuet = Thread(target=self.queue_thread)
diff --git a/zirc/loop.py b/zirc/loop.py
@@ -9,8 +9,10 @@ def __init__(self, recv_func):
         self.current_job = None
         self.break_loop = False
         self.recv_func = recv_func
+
     def create_job(self, name, method, do_thread=False):
         self.jobs[name] = {"method": method, "thread": do_thread}
+
     def run(self):
         while True:
             try:
@@ -24,6 +26,7 @@ def run(self):
                     self.cycles += 1
             except KeyboardInterrupt:
                 break
+
     def join(self):
         """returns None when the current job is complete"""
         while self.current_job is not None:
diff --git a/zirc/util/__init__.py b/zirc/util/__init__.py
@@ -8,11 +8,11 @@ def function_argument_call(func, arguments, do_thread=True):
     x = {}
     for val, arg in enumerate(accepts):
         if val == 0 and (inspect.ismethod(func) or inspect.isclass(func)):
-            continue #Ingnore first argument if it is a method
+            continue  # Ingnore first argument if it is a method
         x[arg] = arguments.get(arg, None)
     if do_thread:
         thread = threading.Thread(target=func, kwargs=x)
         thread.daemon = True
         return thread.start
     call_func = lambda: func(**x)
-    return call_func
+    return call_func
diff --git a/zirc/util/repl.py b/zirc/util/repl.py
@@ -21,7 +21,7 @@ def run(self, data):
 
     def showtraceback(self):
         exc_type, value, lasttb = sys.exc_info()
-        self._buffer+="{0}: {1}".format(exc_type.__name__, value)
+        self._buffer += "{0}: {1}".format(exc_type.__name__, value)
 
     def showsyntaxerror(self, *args):
         self.showtraceback()
