diff --git a/TestON/drivers/common/cli/emulator/lincoedriver.py b/TestON/drivers/common/cli/emulator/lincoedriver.py
index 8da1700..2cb7c98 100644
--- a/TestON/drivers/common/cli/emulator/lincoedriver.py
+++ b/TestON/drivers/common/cli/emulator/lincoedriver.py
@@ -161,7 +161,7 @@
         be created. They must be brought up manually
         '''
         try:
-            self.handle.sendline("ifconfig "+str(intf)+" up")
+            self.handle.sendline("ifconfig "+str(intfs)+" up")
             self.handle.expect("linc@")
    
             handle = self.handle.before
diff --git a/TestON/drivers/common/cli/emulator/mininetclidriver.py b/TestON/drivers/common/cli/emulator/mininetclidriver.py
index bbff01d..c125fca 100644
--- a/TestON/drivers/common/cli/emulator/mininetclidriver.py
+++ b/TestON/drivers/common/cli/emulator/mininetclidriver.py
@@ -1,770 +1,896 @@
 #!/usr/bin/env python
-'''
+"""
 Created on 26-Oct-2012
 
-@author: Anil Kumar (anilkumar.s@paxterrasolutions.com)
+author:: Anil Kumar ( anilkumar.s@paxterrasolutions.com )
 
 
-    TestON is free software: you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 2 of the License, or
-    (at your option) any later version.
+TestON is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 2 of the License, or
+( at your option ) any later version.
 
-    TestON is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
+TestON is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
 
-    You should have received a copy of the GNU General Public License
-    along with TestON.  If not, see <http://www.gnu.org/licenses/>.		
+You should have received a copy of the GNU General Public License
+along with TestON.  If not, see <http://www.gnu.org/licenses/>.
 
 
-MininetCliDriver is the basic driver which will handle the Mininet functions
-'''
+MininetCliDriver is the basic driver which will handle the Mininet functions"""
 import traceback
 import pexpect
-import struct
-import fcntl
-import os
-import signal
 import re
 import sys
-import core.teston
-sys.path.append("../")
+sys.path.append( "../" )
 from math import pow
 from drivers.common.cli.emulatordriver import Emulator
-from drivers.common.clidriver import CLI
 
-class MininetCliDriver(Emulator):
-    '''
-    MininetCliDriver is the basic driver which will handle the Mininet functions
-    '''
-    def __init__(self):
-        super(Emulator, self).__init__()
+
+class MininetCliDriver( Emulator ):
+
+    """
+       MininetCliDriver is the basic driver which will handle
+       the Mininet functions"""
+    def __init__( self ):
+        super( Emulator, self ).__init__()
         self.handle = self
-        self.wrapped = sys.modules[__name__]
+        self.wrapped = sys.modules[ __name__ ]
         self.flag = 0
 
-    def connect(self, **connectargs):
-        '''
-        Here the main is the TestON instance after creating all the log handles.
-        '''
+    def connect( self, **connectargs ):
+        """
+           Here the main is the TestON instance after creating
+           all the log handles."""
         for key in connectargs:
-            vars(self)[key] = connectargs[key]       
-        
-        self.name = self.options['name']
-        self.handle = super(MininetCliDriver, self).connect(user_name = self.user_name, ip_address = self.ip_address,port = None, pwd = self.pwd)
-        
+            vars( self )[ key ] = connectargs[ key ]
+
+        self.name = self.options[ 'name' ]
+        self.handle = super(
+            MininetCliDriver,
+            self ).connect(
+            user_name=self.user_name,
+            ip_address=self.ip_address,
+            port=None,
+            pwd=self.pwd )
+
         self.ssh_handle = self.handle
-        
-        if self.handle :
-            main.log.info(self.name+": Clearing any residual state or processes")
-            self.handle.sendline("sudo mn -c")
-            i=self.handle.expect(['password\sfor\s','Cleanup\scomplete',pexpect.EOF,pexpect.TIMEOUT],120)
-            if i==0:
-                main.log.info(self.name+": Sending sudo password")
-                self.handle.sendline(self.pwd)
-                i=self.handle.expect(['%s:'%(self.user),'\$',pexpect.EOF,pexpect.TIMEOUT],120) 
-            if i==1:
-                main.log.info(self.name+": Clean")
-            elif i==2:
-                main.log.error(self.name+": Connection terminated")
-            elif i==3: #timeout
-                main.log.error(self.name+": Something while cleaning MN took too long... " )
- 
-            main.log.info(self.name+": building fresh mininet") 
-            #### for reactive/PARP enabled tests
-            cmdString = "sudo mn " + self.options['arg1'] + " " + self.options['arg2'] +  " --mac --controller " + self.options['controller'] + " " + self.options['arg3']
-            
-            argList = self.options['arg1'].split(",")
+
+        if self.handle:
+            main.log.info(
+                self.name +
+                ": Clearing any residual state or processes" )
+            self.handle.sendline( "sudo mn -c" )
+            i = self.handle.expect( [ 'password\sfor\s',
+                                      'Cleanup\scomplete',
+                                      pexpect.EOF,
+                                      pexpect.TIMEOUT ],
+                                    120 )
+            if i == 0:
+                main.log.info( self.name + ": Sending sudo password" )
+                self.handle.sendline( self.pwd )
+                i = self.handle.expect( [ '%s:' % ( self.user ),
+                                          '\$',
+                                          pexpect.EOF,
+                                          pexpect.TIMEOUT ],
+                                        120 )
+            if i == 1:
+                main.log.info( self.name + ": Clean" )
+            elif i == 2:
+                main.log.error( self.name + ": Connection terminated" )
+            elif i == 3:  # timeout
+                main.log.error(
+                    self.name +
+                    ": Something while cleaning MN took too long... " )
+
+            main.log.info( self.name + ": building fresh mininet" )
+            # for reactive/PARP enabled tests
+            cmdString = "sudo mn " + self.options[ 'arg1' ] +\
+                    " " + self.options[ 'arg2' ] +\
+                    " --mac --controller " +\
+                    self.options[ 'controller' ] + " " +\
+                    self.options[ 'arg3' ]
+
+            argList = self.options[ 'arg1' ].split( "," )
             global topoArgList
-            topoArgList = argList[0].split(" ")
-            argList = map(int, argList[1:])
-            topoArgList = topoArgList[1:] + argList
-            
-          #### for proactive flow with static ARP entries
-            #cmdString = "sudo mn " + self.options['arg1'] + " " + self.options['arg2'] +  " --mac --arp --controller " + self.options['controller'] + " " + self.options['arg3']
-            self.handle.sendline(cmdString)
-            self.handle.expect(["sudo mn",pexpect.EOF,pexpect.TIMEOUT])
-            while 1: 
-                i=self.handle.expect(['mininet>','\*\*\*','Exception',pexpect.EOF,pexpect.TIMEOUT],300)
-                if i==0:
-                    main.log.info(self.name+": mininet built") 
+            topoArgList = argList[ 0 ].split( " " )
+            argList = map( int, argList[ 1: ] )
+            topoArgList = topoArgList[ 1: ] + argList
+
+            self.handle.sendline( cmdString )
+            self.handle.expect( [ "sudo mn", pexpect.EOF, pexpect.TIMEOUT ] )
+            while True:
+                i = self.handle.expect( [ 'mininet>',
+                                          '\*\*\*',
+                                          'Exception',
+                                          pexpect.EOF,
+                                          pexpect.TIMEOUT ],
+                                        300 )
+                if i == 0:
+                    main.log.info( self.name + ": mininet built" )
                     return main.TRUE
-                if i==1:
-                    self.handle.expect(["\n",pexpect.EOF,pexpect.TIMEOUT])
-                    main.log.info(self.handle.before)
-                elif i==2:
-                    main.log.error(self.name+": Launching mininet failed...")
+                if i == 1:
+                    self.handle.expect(
+                        [ "\n", pexpect.EOF, pexpect.TIMEOUT ] )
+                    main.log.info( self.handle.before )
+                elif i == 2:
+                    main.log.error(
+                        self.name +
+                        ": Launching mininet failed..." )
                     return main.FALSE
-                elif i==3:
-                    main.log.error(self.name+": Connection timeout")
+                elif i == 3:
+                    main.log.error( self.name + ": Connection timeout" )
                     return main.FALSE
-                elif i==4: #timeout
-                    main.log.error(self.name+": Something took too long... " )
+                elif i == 4:  # timeout
+                    main.log.error(
+                        self.name +
+                        ": Something took too long... " )
                     return main.FALSE
-            #if utilities.assert_matches(expect=patterns,actual=resultCommand,onpass="Network is being launched",onfail="Network launching is being failed "):
             return main.TRUE
-        else:#if no handle
-            main.log.error(self.name+": Connection failed to the host "+self.user_name+"@"+self.ip_address) 
-            main.log.error(self.name+": Failed to connect to the Mininet")
+        else:  # if no handle
+            main.log.error(
+                self.name +
+                ": Connection failed to the host " +
+                self.user_name +
+                "@" +
+                self.ip_address )
+            main.log.error( self.name + ": Failed to connect to the Mininet" )
             return main.FALSE
-                    
-    def num_switches_n_links(self,topoType,depth,fanout):
+
+    def num_switches_n_links( self, topoType, depth, fanout ):
         if topoType == 'tree':
-            if fanout is None:     #In tree topology, if fanout arg is not given, by default it is 2
+            # In tree topology, if fanout arg is not given, by default it is 2
+            if fanout is None:
                 fanout = 2
             k = 0
             count = 0
-            while(k <= depth-1): 
-                count = count + pow(fanout,k)
-                k = k+1
+            while( k <= depth - 1 ):
+                count = count + pow( fanout, k )
+                k = k + 1
                 num_switches = count
-            while(k <= depth-2): 
-                '''depth-2 gives you only core links and not considering edge links as seen by ONOS
-                    If all the links including edge links are required, do depth-1
-                '''
-                count = count + pow(fanout,k)
-                k = k+1
+            while( k <= depth - 2 ):
+                # depth-2 gives you only core links and not considering
+                # edge links as seen by ONOS. If all the links including
+                # edge links are required, do depth-1
+                count = count + pow( fanout, k )
+                k = k + 1
             num_links = count * fanout
-            #print "num_switches for %s(%d,%d) = %d and links=%d" %(topoType,depth,fanout,num_switches,num_links)
-        
-        elif topoType =='linear':
-            if fanout is None:     #In linear topology, if fanout or num_hosts_per_sw is not given, by default it is 1
+            # print "num_switches for %s(%d,%d) = %d and links=%d" %(
+            # topoType,depth,fanout,num_switches,num_links )
+
+        elif topoType == 'linear':
+            # In linear topology, if fanout or num_hosts_per_sw is not given,
+            # by default it is 1
+            if fanout is None:
                 fanout = 1
             num_switches = depth
             num_hosts_per_sw = fanout
             total_num_hosts = num_switches * num_hosts_per_sw
-            num_links = total_num_hosts + (num_switches - 1)
-            print "num_switches for %s(%d,%d) = %d and links=%d" %(topoType,depth,fanout,num_switches,num_links) 
+            num_links = total_num_hosts + ( num_switches - 1 )
+            print "num_switches for %s(%d,%d) = %d and links=%d" %\
+                    ( topoType, depth, fanout, num_switches, num_links )
         topoDict = {}
-        topoDict = {"num_switches":int(num_switches), "num_corelinks":int(num_links)}
+        topoDict = {
+            "num_switches": int( num_switches ),
+            "num_corelinks": int( num_links ) }
         return topoDict
 
-
-    def calculate_sw_and_links(self):
-        topoDict = self.num_switches_n_links(*topoArgList)
+    def calculate_sw_and_links( self ):
+        topoDict = self.num_switches_n_links( *topoArgList )
         return topoDict
 
-    def pingall(self, timeout=300):
-        '''
-        Verifies the reachability of the hosts using pingall command.
-        Optional parameter timeout allows you to specify how long to wait for pingall to complete
-        Returns:
-                main.TRUE if pingall completes with no pings dropped
-                otherwise main.FALSE
-        '''
-        if self.handle :
-            main.log.info(self.name+": Checking reachabilty to the hosts using pingall")
+    def pingall( self, timeout=300 ):
+        """
+           Verifies the reachability of the hosts using pingall command.
+           Optional parameter timeout allows you to specify how long to
+           wait for pingall to complete
+           Returns:
+           main.TRUE if pingall completes with no pings dropped
+           otherwise main.FALSE"""
+        if self.handle:
+            main.log.info(
+                self.name +
+                ": Checking reachabilty to the hosts using pingall" )
             try:
-                response = self.execute(cmd="pingall",prompt="mininet>",timeout=int(timeout))
+                response = self.execute(
+                    cmd="pingall",
+                    prompt="mininet>",
+                    timeout=int( timeout ) )
             except pexpect.EOF:
-                main.log.error(self.name + ": EOF exception found")
-                main.log.error(self.name + ":     " + self.handle.before)
+                main.log.error( self.name + ": EOF exception found" )
+                main.log.error( self.name + ":     " + self.handle.before )
                 main.cleanup()
                 main.exit()
             except pexpect.TIMEOUT:
-                #We may not want to kill the test if pexpect times out
-                main.log.error(self.name + ": TIMEOUT exception found")
-                main.log.error(self.name + ":     " + str(self.handle.before) )
-            #NOTE: mininet's pingall rounds, so we will check the number of passed and number of failed
-            pattern = "Results\:\s0\%\sdropped\s\((?P<passed>[\d]+)/(?P=passed)"
-            if re.search(pattern,response):
-                main.log.info(self.name+": All hosts are reachable")
+                # We may not want to kill the test if pexpect times out
+                main.log.error( self.name + ": TIMEOUT exception found" )
+                main.log.error( self.name +
+                                ":     " +
+                                str( self.handle.before ) )
+            # NOTE: mininet's pingall rounds, so we will check the number of
+            # passed and number of failed
+            pattern = "Results\:\s0\%\sdropped\s\(" +\
+                    "(?P<passed>[\d]+)/(?P=passed)"
+            if re.search( pattern, response ):
+                main.log.info( self.name + ": All hosts are reachable" )
                 return main.TRUE
             else:
-                main.log.error(self.name+": Unable to reach all the hosts")
-                main.log.info("Pingall ouput: " + str(response))
-                #NOTE: Send ctrl-c to make sure pingall is done
-                self.handle.send("\x03")
-                self.handle.expect("Interrupt")
-                self.handle.expect("mininet>")
+                main.log.error( self.name + ": Unable to reach all the hosts" )
+                main.log.info( "Pingall ouput: " + str( response ) )
+                # NOTE: Send ctrl-c to make sure pingall is done
+                self.handle.send( "\x03" )
+                self.handle.expect( "Interrupt" )
+                self.handle.expect( "mininet>" )
                 return main.FALSE
-        else :
-            main.log.error(self.name+": Connection failed to the host") 
+        else:
+            main.log.error( self.name + ": Connection failed to the host" )
             main.cleanup()
             main.exit()
 
-    def fpingHost(self,**pingParams):
-        ''' 
-        Uses the fping package for faster pinging...
-        *requires fping to be installed on machine running mininet 
-        ''' 
-        args = utilities.parse_args(["SRC","TARGET"],**pingParams)
-        command = args["SRC"] + " fping -i 100 -t 20 -C 1 -q "+args["TARGET"]
-        self.handle.sendline(command) 
-        self.handle.expect([args["TARGET"],pexpect.EOF,pexpect.TIMEOUT]) 
-        self.handle.expect(["mininet",pexpect.EOF,pexpect.TIMEOUT])
-        response = self.handle.before 
-        if re.search(":\s-" ,response):
-            main.log.info(self.name+": Ping fail") 
+    def fpingHost( self, **pingParams ):
+        """
+           Uses the fping package for faster pinging...
+           *requires fping to be installed on machine running mininet"""
+        args = utilities.parse_args( [ "SRC", "TARGET" ], **pingParams )
+        command = args[ "SRC" ] + \
+            " fping -i 100 -t 20 -C 1 -q " + args[ "TARGET" ]
+        self.handle.sendline( command )
+        self.handle.expect(
+            [ args[ "TARGET" ], pexpect.EOF, pexpect.TIMEOUT ] )
+        self.handle.expect( [ "mininet", pexpect.EOF, pexpect.TIMEOUT ] )
+        response = self.handle.before
+        if re.search( ":\s-", response ):
+            main.log.info( self.name + ": Ping fail" )
             return main.FALSE
-        elif re.search(":\s\d{1,2}\.\d\d", response):
-            main.log.info(self.name+": Ping good!")
+        elif re.search( ":\s\d{1,2}\.\d\d", response ):
+            main.log.info( self.name + ": Ping good!" )
             return main.TRUE
-        main.log.info(self.name+": Install fping on mininet machine... ") 
-        main.log.info(self.name+": \n---\n"+response)
+        main.log.info( self.name + ": Install fping on mininet machine... " )
+        main.log.info( self.name + ": \n---\n" + response )
         return main.FALSE
-        
-    def pingHost(self,**pingParams):
-        '''
-        Ping from one mininet host to another
-        Currently the only supported Params: SRC and TARGET
-        '''
-        args = utilities.parse_args(["SRC","TARGET"],**pingParams)
-        #command = args["SRC"] + " ping -" + args["CONTROLLER"] + " " +args ["TARGET"]
-        command = args["SRC"] + " ping "+args ["TARGET"]+" -c 1 -i 1 -W 8"
+
+    def pingHost( self, **pingParams ):
+        """
+           Ping from one mininet host to another
+           Currently the only supported Params: SRC and TARGET"""
+        args = utilities.parse_args( [ "SRC", "TARGET" ], **pingParams )
+        command = args[ "SRC" ] + " ping " + \
+            args[ "TARGET" ] + " -c 1 -i 1 -W 8"
         try:
-            main.log.warn("Sending: " + command)
-            #response = self.execute(cmd=command,prompt="mininet",timeout=10 )
-            self.handle.sendline(command)
-            i = self.handle.expect([command,pexpect.TIMEOUT])
+            main.log.warn( "Sending: " + command )
+            self.handle.sendline( command )
+            i = self.handle.expect( [ command, pexpect.TIMEOUT ] )
             if i == 1:
-                main.log.error(self.name + ": timeout when waiting for response from mininet")
-                main.log.error("response: " + str(self.handle.before))
-            i = self.handle.expect(["mininet>",pexpect.TIMEOUT])
+                main.log.error(
+                    self.name +
+                    ": timeout when waiting for response from mininet" )
+                main.log.error( "response: " + str( self.handle.before ) )
+            i = self.handle.expect( [ "mininet>", pexpect.TIMEOUT ] )
             if i == 1:
-                main.log.error(self.name + ": timeout when waiting for response from mininet")
-                main.log.error("response: " + str(self.handle.before))
+                main.log.error(
+                    self.name +
+                    ": timeout when waiting for response from mininet" )
+                main.log.error( "response: " + str( self.handle.before ) )
             response = self.handle.before
-        except pexpect.EOF:  
-            main.log.error(self.name + ": EOF exception found")
-            main.log.error(self.name + ":     " + self.handle.before)
+        except pexpect.EOF:
+            main.log.error( self.name + ": EOF exception found" )
+            main.log.error( self.name + ":     " + self.handle.before )
             main.cleanup()
             main.exit()
-        main.log.info(self.name+": Ping Response: "+ response )
-        #if utilities.assert_matches(expect=',\s0\%\spacket\sloss',actual=response,onpass="No Packet loss",onfail="Host is not reachable"):
-        if re.search(',\s0\%\spacket\sloss',response):
-            main.log.info(self.name+": no packets lost, host is reachable")
-            main.last_result = main.TRUE 
+        main.log.info( self.name + ": Ping Response: " + response )
+        if re.search( ',\s0\%\spacket\sloss', response ):
+            main.log.info( self.name + ": no packets lost, host is reachable" )
+            main.last_result = main.TRUE
             return main.TRUE
-        else :
-            main.log.error(self.name+": PACKET LOST, HOST IS NOT REACHABLE")
+        else:
+            main.log.error(
+                self.name +
+                ": PACKET LOST, HOST IS NOT REACHABLE" )
             main.last_result = main.FALSE
             return main.FALSE
-    
-    def checkIP(self,host):
-        '''
-        Verifies the host's ip configured or not.
-        '''
-        if self.handle :
+
+    def checkIP( self, host ):
+        """
+           Verifies the host's ip configured or not."""
+        if self.handle:
             try:
-                response = self.execute(cmd=host+" ifconfig",prompt="mininet>",timeout=10)
-            except pexpect.EOF:  
-                main.log.error(self.name + ": EOF exception found")
-                main.log.error(self.name + ":     " + self.handle.before)
+                response = self.execute(
+                    cmd=host +
+                    " ifconfig",
+                    prompt="mininet>",
+                    timeout=10 )
+            except pexpect.EOF:
+                main.log.error( self.name + ": EOF exception found" )
+                main.log.error( self.name + ":     " + self.handle.before )
                 main.cleanup()
                 main.exit()
 
-            pattern = "inet\s(addr|Mask):([0-1]{1}[0-9]{1,2}|2[0-4][0-9]|25[0-5]|[0-9]{1,2}).([0-1]{1}[0-9]{1,2}|2[0-4][0-9]|25[0-5]|[0-9]{1,2}).([0-1]{1}[0-9]{1,2}|2[0-4][0-9]|25[0-5]|[0-9]{1,2}).([0-1]{1}[0-9]{1,2}|2[0-4][0-9]|25[0-5]|[0-9]{1,2})"
-            #pattern = "inet addr:10.0.0.6"  
-            #if utilities.assert_matches(expect=pattern,actual=response,onpass="Host Ip configured properly",onfail="Host IP not found") :
-            if re.search(pattern,response):
-                main.log.info(self.name+": Host Ip configured properly")
+            pattern = "inet\s(addr|Mask):([0-1]{1}[0-9]{1,2}|" +\
+                    "2[0-4][0-9]|25[0-5]|[0-9]{1,2}).([0-1]{1}" +\
+                    "[0-9]{1,2}|2[0-4][0-9]|25[0-5]|[0-9]{1,2})." +\
+                    "([0-1]{1}[0-9]{1,2}|2[0-4][0-9]|25[0-5]|" +\
+                    "[0-9]{1,2}).([0-1]{1}[0-9]{1,2}|2[0-4]" +\
+                    "[0-9]|25[0-5]|[0-9]{1,2})"
+            # pattern = "inet addr:10.0.0.6"
+            if re.search( pattern, response ):
+                main.log.info( self.name + ": Host Ip configured properly" )
                 return main.TRUE
             else:
-                main.log.error(self.name+": Host IP not found")
+                main.log.error( self.name + ": Host IP not found" )
                 return main.FALSE
-        else :
-            main.log.error(self.name+": Connection failed to the host") 
-            
-    def verifySSH(self,**connectargs):
+        else:
+            main.log.error( self.name + ": Connection failed to the host" )
+
+    def verifySSH( self, **connectargs ):
         try:
-            response = self.execute(cmd="h1 /usr/sbin/sshd -D&",prompt="mininet>",timeout=10)
-            response = self.execute(cmd="h4 /usr/sbin/sshd -D&",prompt="mininet>",timeout=10)
+            response = self.execute(
+                cmd="h1 /usr/sbin/sshd -D&",
+                prompt="mininet>",
+                timeout=10 )
+            response = self.execute(
+                cmd="h4 /usr/sbin/sshd -D&",
+                prompt="mininet>",
+                timeout=10 )
             for key in connectargs:
-                vars(self)[key] = connectargs[key]
-            response = self.execute(cmd="xterm h1 h4 ",prompt="mininet>",timeout=10)
-        except pexpect.EOF:  
-            main.log.error(self.name + ": EOF exception found")
-            main.log.error(self.name + ":     " + self.handle.before)
+                vars( self )[ key ] = connectargs[ key ]
+            response = self.execute(
+                cmd="xterm h1 h4 ",
+                prompt="mininet>",
+                timeout=10 )
+        except pexpect.EOF:
+            main.log.error( self.name + ": EOF exception found" )
+            main.log.error( self.name + ":     " + self.handle.before )
             main.cleanup()
             main.exit()
         import time
-        time.sleep(20)
+        time.sleep( 20 )
         if self.flag == 0:
             self.flag = 1
             return main.FALSE
-        else :
+        else:
             return main.TRUE
 
-    
-
-
-    def changeIP(self,host,intf,newIP,newNetmask):
-        '''
-        Changes the ip address of a host on the fly
-        Ex: h2 ifconfig h2-eth0 10.0.1.2 netmask 255.255.255.0
-        '''
+    def changeIP( self, host, intf, newIP, newNetmask ):
+        """
+           Changes the ip address of a host on the fly
+           Ex: h2 ifconfig h2-eth0 10.0.1.2 netmask 255.255.255.0"""
         if self.handle:
             try:
-                cmd = host+" ifconfig "+intf+" "+newIP+" "+'netmask'+" "+newNetmask
-                self.handle.sendline(cmd)
-                self.handle.expect("mininet>")
+                cmd = host + " ifconfig " + intf + " " + \
+                    newIP + " " + 'netmask' + " " + newNetmask
+                self.handle.sendline( cmd )
+                self.handle.expect( "mininet>" )
                 response = self.handle.before
-                main.log.info("response = "+response)
-                main.log.info("Ip of host "+host+" changed to new IP "+newIP)
+                main.log.info( "response = " + response )
+                main.log.info(
+                    "Ip of host " +
+                    host +
+                    " changed to new IP " +
+                    newIP )
                 return main.TRUE
             except pexpect.EOF:
-                main.log.error(self.name + ": EOF exception found")
-                main.log.error(self.name + ":     " + self.handle.before)
+                main.log.error( self.name + ": EOF exception found" )
+                main.log.error( self.name + ":     " + self.handle.before )
                 return main.FALSE
 
-    def changeDefaultGateway(self,host,newGW):
-        '''
-        Changes the default gateway of a host
-        Ex: h1 route add default gw 10.0.1.2
-        '''
+    def changeDefaultGateway( self, host, newGW ):
+        """
+           Changes the default gateway of a host
+           Ex: h1 route add default gw 10.0.1.2"""
         if self.handle:
             try:
-                cmd = host+" route add default gw "+newGW 
-                self.handle.sendline(cmd)
-                self.handle.expect("mininet>")
+                cmd = host + " route add default gw " + newGW
+                self.handle.sendline( cmd )
+                self.handle.expect( "mininet>" )
                 response = self.handle.before
-                main.log.info("response = "+response)
-                main.log.info("Default gateway of host "+host+" changed to "+newGW)
+                main.log.info( "response = " + response )
+                main.log.info(
+                    "Default gateway of host " +
+                    host +
+                    " changed to " +
+                    newGW )
                 return main.TRUE
             except pexpect.EOF:
-                main.log.error(self.name + ": EOF exception found")
-                main.log.error(self.name + ":     " + self.handle.before)
+                main.log.error( self.name + ": EOF exception found" )
+                main.log.error( self.name + ":     " + self.handle.before )
                 return main.FALSE
-  
-    def addStaticMACAddress(self,host,GW,macaddr):
-        '''
-        Changes the mac address of a geateway host
-        '''
+
+    def addStaticMACAddress( self, host, GW, macaddr ):
+        """
+           Changes the mac address of a geateway host"""
         if self.handle:
             try:
-                #h1  arp -s 10.0.1.254 00:00:00:00:11:11 
-                cmd = host+" arp -s "+GW+" "+macaddr
-                self.handle.sendline(cmd)
-                self.handle.expect("mininet>")
+                # h1  arp -s 10.0.1.254 00:00:00:00:11:11
+                cmd = host + " arp -s " + GW + " " + macaddr
+                self.handle.sendline( cmd )
+                self.handle.expect( "mininet>" )
                 response = self.handle.before
-                main.log.info("response = "+response)
-                main.log.info("Mac adrress of gateway "+GW+" changed to "+macaddr)
+                main.log.info( "response = " + response )
+                main.log.info(
+                    "Mac adrress of gateway " +
+                    GW +
+                    " changed to " +
+                    macaddr )
                 return main.TRUE
             except pexpect.EOF:
-                main.log.error(self.name + ": EOF exception found")
-                main.log.error(self.name + ":     " + self.handle.before)
+                main.log.error( self.name + ": EOF exception found" )
+                main.log.error( self.name + ":     " + self.handle.before )
                 return main.FALSE
 
-    def verifyStaticGWandMAC(self,host):
-        '''
-        Verify if the static gateway and mac address assignment 
-        '''
+    def verifyStaticGWandMAC( self, host ):
+        """
+           Verify if the static gateway and mac address assignment"""
         if self.handle:
             try:
-                #h1  arp -an
-                cmd = host+" arp -an "
-                self.handle.sendline(cmd)
-                self.handle.expect("mininet>")
+                # h1  arp -an
+                cmd = host + " arp -an "
+                self.handle.sendline( cmd )
+                self.handle.expect( "mininet>" )
                 response = self.handle.before
-                main.log.info(host+" arp -an = "+response)
+                main.log.info( host + " arp -an = " + response )
                 return main.TRUE
             except pexpect.EOF:
-                main.log.error(self.name + ": EOF exception found")
-                main.log.error(self.name + ":     " + self.handle.before)
+                main.log.error( self.name + ": EOF exception found" )
+                main.log.error( self.name + ":     " + self.handle.before )
                 return main.FALSE
 
-
-
-    def getMacAddress(self,host):
-        '''
-        Verifies the host's ip configured or not.
-        '''
-        if self.handle :
+    def getMacAddress( self, host ):
+        """
+           Verifies the host's ip configured or not."""
+        if self.handle:
             try:
-                response = self.execute(cmd=host+" ifconfig",prompt="mininet>",timeout=10)
-            except pexpect.EOF:  
-                main.log.error(self.name + ": EOF exception found")
-                main.log.error(self.name + ":     " + self.handle.before)
+                response = self.execute(
+                    cmd=host +
+                    " ifconfig",
+                    prompt="mininet>",
+                    timeout=10 )
+            except pexpect.EOF:
+                main.log.error( self.name + ": EOF exception found" )
+                main.log.error( self.name + ":     " + self.handle.before )
                 main.cleanup()
                 main.exit()
 
             pattern = r'HWaddr\s([0-9A-F]{2}[:-]){5}([0-9A-F]{2})'
-            mac_address_search = re.search(pattern, response, re.I)
-            mac_address = mac_address_search.group().split(" ")[1]
-            main.log.info(self.name+": Mac-Address of Host "+ host + " is " + mac_address)
-            return mac_address
-        else :
-            main.log.error(self.name+": Connection failed to the host") 
-
-    def getInterfaceMACAddress(self,host, interface):
-        '''
-            Return the IP address of the interface on the given host
-        '''
-        if self.handle :
-            try:
-                response = self.execute(cmd=host+" ifconfig " + interface,
-                                    prompt="mininet>",timeout=10)
-            except pexpect.EOF:  
-                main.log.error(self.name + ": EOF exception found")
-                main.log.error(self.name + ":     " + self.handle.before)
-                main.cleanup()
-                main.exit()
-
-            pattern = r'HWaddr\s([0-9A-F]{2}[:-]){5}([0-9A-F]{2})'
-            mac_address_search = re.search(pattern, response, re.I)
-            if mac_address_search is None:
-                main.log.info("No mac address found in %s" % response)
-                return main.FALSE
-            mac_address = mac_address_search.group().split(" ")[1]
-            main.log.info("Mac-Address of "+ host + ":"+ interface + " is " + mac_address)
+            mac_address_search = re.search( pattern, response, re.I )
+            mac_address = mac_address_search.group().split( " " )[ 1 ]
+            main.log.info(
+                self.name +
+                ": Mac-Address of Host " +
+                host +
+                " is " +
+                mac_address )
             return mac_address
         else:
-            main.log.error("Connection failed to the host")
+            main.log.error( self.name + ": Connection failed to the host" )
 
-    def getIPAddress(self,host):
-        '''
-        Verifies the host's ip configured or not.
-        '''
-        if self.handle :
+    def getInterfaceMACAddress( self, host, interface ):
+        """
+           Return the IP address of the interface on the given host"""
+        if self.handle:
             try:
-                response = self.execute(cmd=host+" ifconfig",prompt="mininet>",timeout=10)
-            except pexpect.EOF:  
-                main.log.error(self.name + ": EOF exception found")
-                main.log.error(self.name + ":     " + self.handle.before)
+                response = self.execute( cmd=host + " ifconfig " + interface,
+                                         prompt="mininet>", timeout=10 )
+            except pexpect.EOF:
+                main.log.error( self.name + ": EOF exception found" )
+                main.log.error( self.name + ":     " + self.handle.before )
+                main.cleanup()
+                main.exit()
+
+            pattern = r'HWaddr\s([0-9A-F]{2}[:-]){5}([0-9A-F]{2})'
+            mac_address_search = re.search( pattern, response, re.I )
+            if mac_address_search is None:
+                main.log.info( "No mac address found in %s" % response )
+                return main.FALSE
+            mac_address = mac_address_search.group().split( " " )[ 1 ]
+            main.log.info(
+                "Mac-Address of " +
+                host +
+                ":" +
+                interface +
+                " is " +
+                mac_address )
+            return mac_address
+        else:
+            main.log.error( "Connection failed to the host" )
+
+    def getIPAddress( self, host ):
+        """
+           Verifies the host's ip configured or not."""
+        if self.handle:
+            try:
+                response = self.execute(
+                    cmd=host +
+                    " ifconfig",
+                    prompt="mininet>",
+                    timeout=10 )
+            except pexpect.EOF:
+                main.log.error( self.name + ": EOF exception found" )
+                main.log.error( self.name + ":     " + self.handle.before )
                 main.cleanup()
                 main.exit()
 
             pattern = "inet\saddr:(\d+\.\d+\.\d+\.\d+)"
-            ip_address_search = re.search(pattern, response)
-            main.log.info(self.name+": IP-Address of Host "+host +" is "+ip_address_search.group(1))
-            return ip_address_search.group(1)
-        else :
-            main.log.error(self.name+": Connection failed to the host") 
-        
-    def getSwitchDPID(self,switch):
-        '''
-            return the datapath ID of the switch
-        '''
-        if self.handle :
+            ip_address_search = re.search( pattern, response )
+            main.log.info(
+                self.name +
+                ": IP-Address of Host " +
+                host +
+                " is " +
+                ip_address_search.group( 1 ) )
+            return ip_address_search.group( 1 )
+        else:
+            main.log.error( self.name + ": Connection failed to the host" )
+
+    def getSwitchDPID( self, switch ):
+        """
+           return the datapath ID of the switch"""
+        if self.handle:
             cmd = "py %s.dpid" % switch
             try:
-                response = self.execute(cmd=cmd,prompt="mininet>",timeout=10)
-            except pexpect.EOF:  
-                main.log.error(self.name + ": EOF exception found")
-                main.log.error(self.name + ":     " + self.handle.before)
+                response = self.execute(
+                    cmd=cmd,
+                    prompt="mininet>",
+                    timeout=10 )
+            except pexpect.EOF:
+                main.log.error( self.name + ": EOF exception found" )
+                main.log.error( self.name + ":     " + self.handle.before )
                 main.cleanup()
                 main.exit()
             pattern = r'^(?P<dpid>\w)+'
-            result = re.search(pattern, response, re.MULTILINE)
+            result = re.search( pattern, response, re.MULTILINE )
             if result is None:
-                main.log.info("Couldn't find DPID for switch '', found: %s" % (switch, response))
+                main.log.info(
+                    "Couldn't find DPID for switch %s, found: %s" %
+                    ( switch, response ) )
                 return main.FALSE
-            return str(result.group(0)).lower()
+            return str( result.group( 0 ) ).lower()
         else:
-            main.log.error("Connection failed to the host")
+            main.log.error( "Connection failed to the host" )
 
-    def getDPID(self, switch):
+    def getDPID( self, switch ):
         if self.handle:
-            self.handle.sendline("")
-            self.expect("mininet>")
-            cmd = "py %s.dpid" %switch
+            self.handle.sendline( "" )
+            self.expect( "mininet>" )
+            cmd = "py %s.dpid" % switch
             try:
-                response = self.execute(cmd=cmd,prompt="mininet>",timeout=10)
-                self.handle.expect("mininet>")
+                response = self.execute(
+                    cmd=cmd,
+                    prompt="mininet>",
+                    timeout=10 )
+                self.handle.expect( "mininet>" )
                 response = self.handle.before
                 return response
             except pexpect.EOF:
-                main.log.error(self.name + ": EOF exception found")
-                main.log.error(self.name + ":     " + self.handle.before)
+                main.log.error( self.name + ": EOF exception found" )
+                main.log.error( self.name + ":     " + self.handle.before )
                 main.cleanup()
                 main.exit()
 
-
-    def getInterfaces(self, node):
-        '''
-            return information dict about interfaces connected to the node
-        '''
-        if self.handle :
-            cmd = 'py "\\n".join(["name=%s,mac=%s,ip=%s,enabled=%s" % (i.name, i.MAC(), i.IP(), i.isUp())'
+    def getInterfaces( self, node ):
+        """
+           return information dict about interfaces connected to the node"""
+        if self.handle:
+            cmd = 'py "\\n".join(["name=%s,mac=%s,ip=%s,enabled=%s"' +\
+                    ' % (i.name, i.MAC(), i.IP(), i.isUp())'
             cmd += ' for i in %s.intfs.values()])' % node
             try:
-                response = self.execute(cmd=cmd,prompt="mininet>",timeout=10)
-            except pexpect.EOF:  
-                main.log.error(self.name + ": EOF exception found")
-                main.log.error(self.name + ":     " + self.handle.before)
+                response = self.execute(
+                    cmd=cmd,
+                    prompt="mininet>",
+                    timeout=10 )
+            except pexpect.EOF:
+                main.log.error( self.name + ": EOF exception found" )
+                main.log.error( self.name + ":     " + self.handle.before )
                 main.cleanup()
                 main.exit()
             return response
         else:
-            main.log.error("Connection failed to the node")
+            main.log.error( "Connection failed to the node" )
 
-    def dump(self):
-        main.log.info(self.name+": Dump node info")
+    def dump( self ):
+        main.log.info( self.name + ": Dump node info" )
         try:
-            response = self.execute(cmd = 'dump',prompt = 'mininet>',timeout = 10)
-        except pexpect.EOF:  
-            main.log.error(self.name + ": EOF exception found")
-            main.log.error(self.name + ":     " + self.handle.before)
+            response = self.execute(
+                cmd='dump',
+                prompt='mininet>',
+                timeout=10 )
+        except pexpect.EOF:
+            main.log.error( self.name + ": EOF exception found" )
+            main.log.error( self.name + ":     " + self.handle.before )
             main.cleanup()
             main.exit()
         return response
-            
-    def intfs(self):
-        main.log.info(self.name+": List interfaces")
+
+    def intfs( self ):
+        main.log.info( self.name + ": List interfaces" )
         try:
-            response = self.execute(cmd = 'intfs',prompt = 'mininet>',timeout = 10)
-        except pexpect.EOF:  
-            main.log.error(self.name + ": EOF exception found")
-            main.log.error(self.name + ":     " + self.handle.before)
+            response = self.execute(
+                cmd='intfs',
+                prompt='mininet>',
+                timeout=10 )
+        except pexpect.EOF:
+            main.log.error( self.name + ": EOF exception found" )
+            main.log.error( self.name + ":     " + self.handle.before )
             main.cleanup()
             main.exit()
         return response
-    
-    def net(self):
-        main.log.info(self.name+": List network connections")
+
+    def net( self ):
+        main.log.info( self.name + ": List network connections" )
         try:
-            response = self.execute(cmd = 'net',prompt = 'mininet>',timeout = 10)
-        except pexpect.EOF:  
-            main.log.error(self.name + ": EOF exception found")
-            main.log.error(self.name + ":     " + self.handle.before)
+            response = self.execute( cmd='net', prompt='mininet>', timeout=10 )
+        except pexpect.EOF:
+            main.log.error( self.name + ": EOF exception found" )
+            main.log.error( self.name + ":     " + self.handle.before )
             main.cleanup()
             main.exit()
         return response
-    '''
-    def iperf(self,host1,host2):
-        main.log.info(self.name+": Simple iperf TCP test between two (optionally specified) hosts")
+
+    def iperf( self, host1, host2 ):
+        main.log.info(
+            self.name +
+            ": Simple iperf TCP test between two hosts" )
         try:
-            if not host1 and not host2:
-                response = self.execute(cmd = 'iperf',prompt = 'mininet>',timeout = 10)
-            else:
-                cmd1 = 'iperf '+ host1 + " " + host2
-                response = self.execute(cmd = cmd1, prompt = '>',timeout = 20)
-        except pexpect.EOF:  
-            main.log.error(self.name + ": EOF exception found")
-            main.log.error(self.name + ":     " + self.handle.before)
-            main.cleanup()
-            main.exit()
-        return response
-     '''
-    def iperf(self,host1,host2):
-        main.log.info(self.name+": Simple iperf TCP test between two hosts")
-        try:
-            cmd1 = 'iperf '+ host1 + " " + host2
-            self.handle.sendline(cmd1)
-            self.handle.expect("mininet>") 
+            cmd1 = 'iperf ' + host1 + " " + host2
+            self.handle.sendline( cmd1 )
+            self.handle.expect( "mininet>" )
             response = self.handle.before
-            if re.search('Results:',response):
-                main.log.info(self.name+": iperf test succssful")
+            if re.search( 'Results:', response ):
+                main.log.info( self.name + ": iperf test succssful" )
                 return main.TRUE
             else:
-                main.log.error(self.name+": iperf test failed")
-                return main.FALSE 
+                main.log.error( self.name + ": iperf test failed" )
+                return main.FALSE
         except pexpect.EOF:
-            main.log.error(self.name + ": EOF exception found")
-            main.log.error(self.name + ":     " + self.handle.before)
+            main.log.error( self.name + ": EOF exception found" )
+            main.log.error( self.name + ":     " + self.handle.before )
             main.cleanup()
             main.exit()
-    
-    def iperfudp(self):
-        main.log.info(self.name+": Simple iperf TCP test between two (optionally specified) hosts")
+
+    def iperfudp( self ):
+        main.log.info(
+            self.name +
+            ": Simple iperf TCP test between two " +
+            "(optionally specified) hosts" )
         try:
-            response = self.execute(cmd = 'iperfudp',prompt = 'mininet>',timeout = 10)
-        except pexpect.EOF:  
-            main.log.error(self.name + ": EOF exception found")
-            main.log.error(self.name + ":     " + self.handle.before)
+            response = self.execute(
+                cmd='iperfudp',
+                prompt='mininet>',
+                timeout=10 )
+        except pexpect.EOF:
+            main.log.error( self.name + ": EOF exception found" )
+            main.log.error( self.name + ":     " + self.handle.before )
             main.cleanup()
             main.exit()
         return response
-    
-    def nodes(self):
-        main.log.info(self.name+": List all nodes.")
+
+    def nodes( self ):
+        main.log.info( self.name + ": List all nodes." )
         try:
-            response = self.execute(cmd = 'nodes',prompt = 'mininet>',timeout = 10)    
-        except pexpect.EOF:  
-            main.log.error(self.name + ": EOF exception found")
-            main.log.error(self.name + ":     " + self.handle.before)
+            response = self.execute(
+                cmd='nodes',
+                prompt='mininet>',
+                timeout=10 )
+        except pexpect.EOF:
+            main.log.error( self.name + ": EOF exception found" )
+            main.log.error( self.name + ":     " + self.handle.before )
             main.cleanup()
             main.exit()
         return response
-    
-    def pingpair(self):
-        main.log.info(self.name+": Ping between first two hosts")
+
+    def pingpair( self ):
+        main.log.info( self.name + ": Ping between first two hosts" )
         try:
-            response = self.execute(cmd = 'pingpair',prompt = 'mininet>',timeout = 20)
-        except pexpect.EOF:  
-            main.log.error(self.name + ": EOF exception found")
-            main.log.error(self.name + ":     " + self.handle.before)
+            response = self.execute(
+                cmd='pingpair',
+                prompt='mininet>',
+                timeout=20 )
+        except pexpect.EOF:
+            main.log.error( self.name + ": EOF exception found" )
+            main.log.error( self.name + ":     " + self.handle.before )
             main.cleanup()
             main.exit()
-        
-        #if utilities.assert_matches(expect='0% packet loss',actual=response,onpass="No Packet loss",onfail="Hosts not reachable"):
-        if re.search(',\s0\%\spacket\sloss',response):
-            main.log.info(self.name+": Ping between two hosts SUCCESSFUL")
-            main.last_result = main.TRUE 
+
+        if re.search( ',\s0\%\spacket\sloss', response ):
+            main.log.info( self.name + ": Ping between two hosts SUCCESSFUL" )
+            main.last_result = main.TRUE
             return main.TRUE
-        else :
-            main.log.error(self.name+": PACKET LOST, HOSTS NOT REACHABLE")
+        else:
+            main.log.error( self.name + ": PACKET LOST, HOSTS NOT REACHABLE" )
             main.last_result = main.FALSE
             return main.FALSE
-    
-    def link(self,**linkargs):
-        '''
-        Bring link(s) between two nodes up or down
-        '''
-        args = utilities.parse_args(["END1","END2","OPTION"],**linkargs)
-        end1 = args["END1"] if args["END1"] != None else ""
-        end2 = args["END2"] if args["END2"] != None else ""
-        option = args["OPTION"] if args["OPTION"] != None else ""
-        main.log.info("Bring link between '"+ end1 +"' and '" + end2 + "' '" + option + "'")
-        command = "link "+str(end1) + " " + str(end2)+ " " + str(option)
-        try:
-            #response = self.execute(cmd=command,prompt="mininet>",timeout=10)
-            self.handle.sendline(command)
-            self.handle.expect("mininet>")    
-        except pexpect.EOF:  
-            main.log.error(self.name + ": EOF exception found")
-            main.log.error(self.name + ":     " + self.handle.before)
-            main.cleanup()
-            main.exit()
-        return main.TRUE
-        
 
-    def yank(self,**yankargs):
-	'''
-	yank a mininet switch interface to a host
-	'''
-	main.log.info('Yank the switch interface attached to a host')
-	args = utilities.parse_args(["SW","INTF"],**yankargs)
-	sw = args["SW"] if args["SW"] !=None else ""
-	intf = args["INTF"] if args["INTF"] != None else ""
-	command = "py "+ str(sw) + '.detach("' + str(intf) + '")'
+    def link( self, **linkargs ):
+        """
+           Bring link( s ) between two nodes up or down"""
+        args = utilities.parse_args( [ "END1", "END2", "OPTION" ], **linkargs )
+        end1 = args[ "END1" ] if args[ "END1" ] is not None else ""
+        end2 = args[ "END2" ] if args[ "END2" ] is not None else ""
+        option = args[ "OPTION" ] if args[ "OPTION" ] is not None else ""
+        main.log.info(
+            "Bring link between '" +
+            end1 +
+            "' and '" +
+            end2 +
+            "' '" +
+            option +
+            "'" )
+        command = "link " + \
+            str( end1 ) + " " + str( end2 ) + " " + str( option )
         try:
-            response = self.execute(cmd=command,prompt="mininet>",timeout=10)
-        except pexpect.EOF:  
-            main.log.error(self.name + ": EOF exception found")
-            main.log.error(self.name + ":     " + self.handle.before)
-            main.cleanup()
-            main.exit()
-	return main.TRUE
-
-    def plug(self, **plugargs):
-        '''
-        plug the yanked mininet switch interface to a switch
-        '''
-        main.log.info('Plug the switch interface attached to a switch')
-        args = utilities.parse_args(["SW","INTF"],**plugargs)
-        sw = args["SW"] if args["SW"] !=None else ""
-        intf = args["INTF"] if args["INTF"] != None else ""
-        command = "py "+ str(sw) + '.attach("' + str(intf) + '")'
-        try:
-            response = self.execute(cmd=command,prompt="mininet>",timeout=10)
-        except pexpect.EOF:  
-            main.log.error(self.name + ": EOF exception found")
-            main.log.error(self.name + ":     " + self.handle.before)
+            self.handle.sendline( command )
+            self.handle.expect( "mininet>" )
+        except pexpect.EOF:
+            main.log.error( self.name + ": EOF exception found" )
+            main.log.error( self.name + ":     " + self.handle.before )
             main.cleanup()
             main.exit()
         return main.TRUE
 
-
-
-    def dpctl(self,**dpctlargs):
-        '''
-        Run dpctl command on all switches.
-        '''
-        main.log.info('Run dpctl command on all switches')
-        args = utilities.parse_args(["CMD","ARGS"],**dpctlargs)
-        cmd = args["CMD"] if args["CMD"] != None else ""
-        cmdargs = args["ARGS"] if args["ARGS"] != None else ""
-        command = "dpctl "+cmd + " " + str(cmdargs)
+    def yank( self, **yankargs ):
+        """
+           yank a mininet switch interface to a host"""
+        main.log.info( 'Yank the switch interface attached to a host' )
+        args = utilities.parse_args( [ "SW", "INTF" ], **yankargs )
+        sw = args[ "SW" ] if args[ "SW" ] is not None else ""
+        intf = args[ "INTF" ] if args[ "INTF" ] is not None else ""
+        command = "py " + str( sw ) + '.detach("' + str(intf) + '")'
         try:
-            response = self.execute(cmd=command,prompt="mininet>",timeout=10)
-        except pexpect.EOF:  
-            main.log.error(self.name + ": EOF exception found")
-            main.log.error(self.name + ":     " + self.handle.before)
+            response = self.execute(
+                cmd=command,
+                prompt="mininet>",
+                timeout=10 )
+        except pexpect.EOF:
+            main.log.error( self.name + ": EOF exception found" )
+            main.log.error( self.name + ":     " + self.handle.before )
             main.cleanup()
             main.exit()
         return main.TRUE
-   
-        
-    def get_version(self):
-        file_input = path+'/lib/Mininet/INSTALL'
-        version = super(Mininet, self).get_version()
+
+    def plug( self, **plugargs ):
+        """
+           plug the yanked mininet switch interface to a switch"""
+        main.log.info( 'Plug the switch interface attached to a switch' )
+        args = utilities.parse_args( [ "SW", "INTF" ], **plugargs )
+        sw = args[ "SW" ] if args[ "SW" ] is not None else ""
+        intf = args[ "INTF" ] if args[ "INTF" ] is not None else ""
+        command = "py " + str( sw ) + '.attach("' + str(intf) + '")'
+        try:
+            response = self.execute(
+                cmd=command,
+                prompt="mininet>",
+                timeout=10 )
+        except pexpect.EOF:
+            main.log.error( self.name + ": EOF exception found" )
+            main.log.error( self.name + ":     " + self.handle.before )
+            main.cleanup()
+            main.exit()
+        return main.TRUE
+
+    def dpctl( self, **dpctlargs ):
+        """
+           Run dpctl command on all switches."""
+        main.log.info( 'Run dpctl command on all switches' )
+        args = utilities.parse_args( [ "CMD", "ARGS" ], **dpctlargs )
+        cmd = args[ "CMD" ] if args[ "CMD" ] is not None else ""
+        cmdargs = args[ "ARGS" ] if args[ "ARGS" ] is not None else ""
+        command = "dpctl " + cmd + " " + str( cmdargs )
+        try:
+            response = self.execute(
+                cmd=command,
+                prompt="mininet>",
+                timeout=10 )
+        except pexpect.EOF:
+            main.log.error( self.name + ": EOF exception found" )
+            main.log.error( self.name + ":     " + self.handle.before )
+            main.cleanup()
+            main.exit()
+        return main.TRUE
+
+    def get_version( self ):
+        file_input = path + '/lib/Mininet/INSTALL'
+        version = super( Mininet, self ).get_version()
         pattern = 'Mininet\s\w\.\w\.\w\w*'
-        for line in open(file_input,'r').readlines():
-            result = re.match(pattern, line)
+        for line in open( file_input, 'r' ).readlines():
+            result = re.match( pattern, line )
             if result:
-                version = result.group(0)
+                version = result.group( 0 )
         return version
 
-    def get_sw_controller(self, sw):
-        '''
+    def get_sw_controller( self, sw ):
+        """
         Parameters:
             sw: The name of an OVS switch. Example "s1"
         Return:
-            The output of the command from the mininet cli or main.FALSE on timeout
-        '''
-        command = "sh ovs-vsctl get-controller "+str(sw)
+            The output of the command from the mininet cli
+            or main.FALSE on timeout"""
+        command = "sh ovs-vsctl get-controller " + str( sw )
         try:
-            response = self.execute(cmd=command, prompt="mininet>", timeout=10)
+            response = self.execute(
+                cmd=command,
+                prompt="mininet>",
+                timeout=10 )
             if response:
                 return response
             else:
                 return main.FALSE
         except pexpect.EOF:
-            main.log.error(self.name + ": EOF exception found")
-            main.log.error(self.name + ":     " + self.handle.before)
+            main.log.error( self.name + ": EOF exception found" )
+            main.log.error( self.name + ":     " + self.handle.before )
             main.cleanup()
             main.exit()
 
-    def assign_sw_controller(self,**kwargs):
-        '''
-        count is only needed if there is more than 1 controller
-        '''
-        args = utilities.parse_args(["COUNT"],**kwargs)
-        count = args["COUNT"] if args!={} else 1
+    def assign_sw_controller( self, **kwargs ):
+        """
+           count is only needed if there is more than 1 controller"""
+        args = utilities.parse_args( [ "COUNT" ], **kwargs )
+        count = args[ "COUNT" ] if args != {} else 1
 
         argstring = "SW"
-        for j in range(count):
-            argstring = argstring + ",IP" + str(j+1) + ",PORT" + str(j+1)
-        args = utilities.parse_args(argstring.split(","),**kwargs)
+        for j in range( count ):
+            argstring = argstring + ",IP" + \
+                str( j + 1 ) + ",PORT" + str( j + 1 )
+        args = utilities.parse_args( argstring.split( "," ), **kwargs )
 
-        sw = args["SW"] if args["SW"] != None else ""
-        ptcpA = int(args["PORT1"])+int(sw) if args["PORT1"] != None else ""
-        ptcpB = "ptcp:"+str(ptcpA) if ptcpA != "" else ""
-        
-        command = "sh ovs-vsctl set-controller s" + str(sw) + " " + ptcpB + " "
-        for j in range(count):
-            i=j+1
-            args = utilities.parse_args(["IP"+str(i),"PORT"+str(i)],**kwargs)
-            ip = args["IP"+str(i)] if args["IP"+str(i)] != None else ""
-            port = args["PORT" + str(i)] if args["PORT" + str(i)] != None else ""
-            tcp = "tcp:" + str(ip) + ":" + str(port) + " " if ip != "" else ""
+        sw = args[ "SW" ] if args[ "SW" ] is not None else ""
+        ptcpA = int( args[ "PORT1" ] ) + \
+                    int( sw ) if args[ "PORT1" ] is not None else ""
+        ptcpB = "ptcp:" + str( ptcpA ) if ptcpA != "" else ""
+
+        command = "sh ovs-vsctl set-controller s" + \
+            str( sw ) + " " + ptcpB + " "
+        for j in range( count ):
+            i = j + 1
+            args = utilities.parse_args(
+                [ "IP" + str( i ), "PORT" + str( i ) ], **kwargs )
+            ip = args[
+                "IP" +
+                str( i ) ] if args[
+                "IP" +
+                str( i ) ] is not None else ""
+            port = args[
+                "PORT" +
+                str( i ) ] if args[
+                "PORT" +
+                str( i ) ] is not None else ""
+            tcp = "tcp:" + str( ip ) + ":" + str( port ) + \
+                               " " if ip != "" else ""
             command = command + tcp
         try:
-            self.execute(cmd=command,prompt="mininet>",timeout=5)
+            self.execute( cmd=command, prompt="mininet>", timeout=5 )
         except pexpect.EOF:
-            main.log.error(self.name + ": EOF exception found")
-            main.log.error(self.name + ":     " + self.handle.before)
+            main.log.error( self.name + ": EOF exception found" )
+            main.log.error( self.name + ":     " + self.handle.before )
             main.cleanup()
             main.exit()
         except:
-            main.log.info(self.name + ":::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::")
+            main.log.info( self.name + ":" * 50 )
             main.log.error( traceback.print_exc() )
-            main.log.info(":::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::")
+            main.log.info(":" * 50 )
             main.cleanup()
             main.exit()
 
-    def delete_sw_controller(self,sw):
-        '''
-        Removes the controller target from sw
-        '''
-
-        command = "sh ovs-vsctl del-controller "+str(sw)
+    def delete_sw_controller( self, sw ):
+        """
+           Removes the controller target from sw"""
+        command = "sh ovs-vsctl del-controller " + str( sw )
         try:
-            response = self.execute(cmd=command,prompt="mininet>",timeout=10)
-        except pexpect.EOF:  
-            main.log.error(self.name + ": EOF exception found")
-            main.log.error(self.name + ":     " + self.handle.before)
+            response = self.execute(
+                cmd=command,
+                prompt="mininet>",
+                timeout=10 )
+        except pexpect.EOF:
+            main.log.error( self.name + ": EOF exception found" )
+            main.log.error( self.name + ":     " + self.handle.before )
             main.cleanup()
             main.exit()
         else:
-            main.log.info(response)
+            main.log.info( response )
 
     def add_switch( self, sw, **kwargs ):
-        '''
+        """
         adds a switch to the mininet topology
         NOTE: this uses a custom mn function
         NOTE: cannot currently specify what type of switch
@@ -773,117 +899,126 @@
         optional keyvalues:
             dpid = "dpid"
         returns: main.FASLE on an error, else main.TRUE
-        '''
-        dpid = kwargs.get('dpid', '')
+        """
+        dpid = kwargs.get( 'dpid', '' )
         command = "addswitch " + str( sw ) + " " + str( dpid )
         try:
-            response = self.execute(cmd=command,prompt="mininet>",timeout=10)
-            if re.search("already exists!", response):
-                main.log.warn(response)
+            response = self.execute(
+                cmd=command,
+                prompt="mininet>",
+                timeout=10 )
+            if re.search( "already exists!", response ):
+                main.log.warn( response )
                 return main.FALSE
-            elif re.search("Error", response):
-                main.log.warn(response)
+            elif re.search( "Error", response ):
+                main.log.warn( response )
                 return main.FALSE
-            elif re.search("usage:", response):
-                main.log.warn(response)
+            elif re.search( "usage:", response ):
+                main.log.warn( response )
                 return main.FALSE
             else:
                 return main.TRUE
         except pexpect.EOF:
-            main.log.error(self.name + ": EOF exception found")
-            main.log.error(self.name + ":     " + self.handle.before)
+            main.log.error( self.name + ": EOF exception found" )
+            main.log.error( self.name + ":     " + self.handle.before )
             main.cleanup()
             main.exit()
 
     def del_switch( self, sw ):
-        '''
-        delete a switch from the mininet topology
-        NOTE: this uses a custom mn function
-        required params:
+        """
+           delete a switch from the mininet topology
+           NOTE: this uses a custom mn function
+           required params:
             switchname = name of the switch as a string
-        returns: main.FASLE on an error, else main.TRUE
-        '''
+           returns: main.FASLE on an error, else main.TRUE"""
         command = "delswitch " + str( sw )
         try:
-            response = self.execute(cmd=command,prompt="mininet>",timeout=10)
-            if re.search("no switch named", response):
-                main.log.warn(response)
+            response = self.execute(
+                cmd=command,
+                prompt="mininet>",
+                timeout=10 )
+            if re.search( "no switch named", response ):
+                main.log.warn( response )
                 return main.FALSE
-            elif re.search("Error", response):
-                main.log.warn(response)
+            elif re.search( "Error", response ):
+                main.log.warn( response )
                 return main.FALSE
-            elif re.search("usage:", response):
-                main.log.warn(response)
+            elif re.search( "usage:", response ):
+                main.log.warn( response )
                 return main.FALSE
             else:
                 return main.TRUE
         except pexpect.EOF:
-            main.log.error(self.name + ": EOF exception found")
-            main.log.error(self.name + ":     " + self.handle.before)
+            main.log.error( self.name + ": EOF exception found" )
+            main.log.error( self.name + ":     " + self.handle.before )
             main.cleanup()
             main.exit()
 
     def add_link( self, node1, node2 ):
-        '''
-        add a link to the mininet topology
-        NOTE: this uses a custom mn function
-        NOTE: cannot currently specify what type of link
-        required params:
-            node1 = the string node name of the first endpoint of the link
-            node2 = the string node name of the second endpoint of the link
-        returns: main.FASLE on an error, else main.TRUE
-        '''
+        """
+           add a link to the mininet topology
+           NOTE: this uses a custom mn function
+           NOTE: cannot currently specify what type of link
+           required params:
+           node1 = the string node name of the first endpoint of the link
+           node2 = the string node name of the second endpoint of the link
+           returns: main.FASLE on an error, else main.TRUE"""
         command = "addlink " + str( node1 ) + " " + str( node2 )
         try:
-            response = self.execute(cmd=command,prompt="mininet>",timeout=10)
-            if re.search("doesnt exist!", response):
-                main.log.warn(response)
+            response = self.execute(
+                cmd=command,
+                prompt="mininet>",
+                timeout=10 )
+            if re.search( "doesnt exist!", response ):
+                main.log.warn( response )
                 return main.FALSE
-            elif re.search("Error", response):
-                main.log.warn(response)
+            elif re.search( "Error", response ):
+                main.log.warn( response )
                 return main.FALSE
-            elif re.search("usage:", response):
-                main.log.warn(response)
+            elif re.search( "usage:", response ):
+                main.log.warn( response )
                 return main.FALSE
             else:
                 return main.TRUE
         except pexpect.EOF:
-            main.log.error(self.name + ": EOF exception found")
-            main.log.error(self.name + ":     " + self.handle.before)
+            main.log.error( self.name + ": EOF exception found" )
+            main.log.error( self.name + ":     " + self.handle.before )
             main.cleanup()
             main.exit()
 
     def del_link( self, node1, node2 ):
-        '''
-        delete a link from the mininet topology
-        NOTE: this uses a custom mn function
-        required params:
-            node1 = the string node name of the first endpoint of the link
-            node2 = the string node name of the second endpoint of the link
-        returns: main.FASLE on an error, else main.TRUE
-        '''
+        """
+           delete a link from the mininet topology
+           NOTE: this uses a custom mn function
+           required params:
+           node1 = the string node name of the first endpoint of the link
+           node2 = the string node name of the second endpoint of the link
+           returns: main.FASLE on an error, else main.TRUE"""
         command = "dellink " + str( node1 ) + " " + str( node2 )
         try:
-            response = self.execute(cmd=command,prompt="mininet>",timeout=10)
-            if re.search("no node named", response):
-                main.log.warn(response)
+            response = self.execute(
+                cmd=command,
+                prompt="mininet>",
+                timeout=10 )
+            if re.search( "no node named", response ):
+                main.log.warn( response )
                 return main.FALSE
-            elif re.search("Error", response):
-                main.log.warn(response)
+            elif re.search( "Error", response ):
+                main.log.warn( response )
                 return main.FALSE
-            elif re.search("usage:", response):
-                main.log.warn(response)
+            elif re.search( "usage:", response ):
+                main.log.warn( response )
                 return main.FALSE
             else:
                 return main.TRUE
         except pexpect.EOF:
-            main.log.error(self.name + ": EOF exception found")
-            main.log.error(self.name + ":     " + self.handle.before)
+            main.log.error( self.name + ": EOF exception found" )
+            main.log.error( self.name + ":     " + self.handle.before )
             main.cleanup()
             main.exit()
 
     def add_host( self, hostname, **kwargs ):
-        '''
+        """
         Add a host to the mininet topology
         NOTE: this uses a custom mn function
         NOTE: cannot currently specify what type of host
@@ -892,515 +1027,603 @@
         optional key-value params
             switch = "switch name"
             returns: main.FASLE on an error, else main.TRUE
-        '''
-        switch = kwargs.get('switch', '')
+        """
+        switch = kwargs.get( 'switch', '' )
         command = "addhost " + str( hostname ) + " " + str( switch )
         try:
-            response = self.execute(cmd=command,prompt="mininet>",timeout=10)
-            if re.search("already exists!", response):
-                main.log.warn(response)
+            response = self.execute(
+                cmd=command,
+                prompt="mininet>",
+                timeout=10 )
+            if re.search( "already exists!", response ):
+                main.log.warn( response )
                 return main.FALSE
-            elif re.search("doesnt exists!", response):
-                main.log.warn(response)
+            elif re.search( "doesnt exists!", response ):
+                main.log.warn( response )
                 return main.FALSE
-            elif re.search("Error", response):
-                main.log.warn(response)
+            elif re.search( "Error", response ):
+                main.log.warn( response )
                 return main.FALSE
-            elif re.search("usage:", response):
-                main.log.warn(response)
+            elif re.search( "usage:", response ):
+                main.log.warn( response )
                 return main.FALSE
             else:
                 return main.TRUE
         except pexpect.EOF:
-            main.log.error(self.name + ": EOF exception found")
-            main.log.error(self.name + ":     " + self.handle.before)
+            main.log.error( self.name + ": EOF exception found" )
+            main.log.error( self.name + ":     " + self.handle.before )
             main.cleanup()
             main.exit()
 
     def del_host( self, hostname ):
-        '''
-        delete a host from the mininet topology
-        NOTE: this uses a custom mn function
-        required params:
-            hostname = the string hostname
-            returns: main.FASLE on an error, else main.TRUE
-        '''
+        """
+           delete a host from the mininet topology
+           NOTE: this uses a custom mn function
+           required params:
+           hostname = the string hostname
+           returns: main.FASLE on an error, else main.TRUE"""
         command = "delhost " + str( hostname )
         try:
-            response = self.execute(cmd=command,prompt="mininet>",timeout=10)
-            if re.search("no host named", response):
-                main.log.warn(response)
+            response = self.execute(
+                cmd=command,
+                prompt="mininet>",
+                timeout=10 )
+            if re.search( "no host named", response ):
+                main.log.warn( response )
                 return main.FALSE
-            elif re.search("Error", response):
-                main.log.warn(response)
+            elif re.search( "Error", response ):
+                main.log.warn( response )
                 return main.FALSE
-            elif re.search("usage:", response):
-                main.log.warn(response)
+            elif re.search( "usage:", response ):
+                main.log.warn( response )
                 return main.FALSE
             else:
                 return main.TRUE
         except pexpect.EOF:
-            main.log.error(self.name + ": EOF exception found")
-            main.log.error(self.name + ":     " + self.handle.before)
+            main.log.error( self.name + ": EOF exception found" )
+            main.log.error( self.name + ":     " + self.handle.before )
             main.cleanup()
             main.exit()
 
-    def disconnect(self):
-        main.log.info(self.name+": Disconnecting mininet...")
+    def disconnect( self ):
+        main.log.info( self.name + ": Disconnecting mininet..." )
         response = ''
         if self.handle:
             try:
-                response = self.execute(cmd="exit",prompt="(.*)",timeout=120)
-                response = self.execute(cmd="exit",prompt="(.*)",timeout=120)
-                self.handle.sendline("sudo mn -c")
+                response = self.execute(
+                    cmd="exit",
+                    prompt="(.*)",
+                    timeout=120 )
+                response = self.execute(
+                    cmd="exit",
+                    prompt="(.*)",
+                    timeout=120 )
+                self.handle.sendline( "sudo mn -c" )
                 response = main.TRUE
-            except pexpect.EOF:  
-                main.log.error(self.name + ": EOF exception found")
-                main.log.error(self.name + ":     " + self.handle.before)
+            except pexpect.EOF:
+                main.log.error( self.name + ": EOF exception found" )
+                main.log.error( self.name + ":     " + self.handle.before )
                 main.cleanup()
                 main.exit()
-        else :
-            main.log.error(self.name+": Connection failed to the host")
+        else:
+            main.log.error( self.name + ": Connection failed to the host" )
             response = main.FALSE
-        return response  
-  
-    def arping(self, src, dest, destmac):
-        self.handle.sendline('')
-        self.handle.expect(["mininet",pexpect.EOF,pexpect.TIMEOUT])
+        return response
 
-        self.handle.sendline(src + ' arping ' + dest)
+    def arping( self, src, dest, destmac ):
+        self.handle.sendline( '' )
+        self.handle.expect( [ "mininet", pexpect.EOF, pexpect.TIMEOUT ] )
+
+        self.handle.sendline( src + ' arping ' + dest )
         try:
-            self.handle.expect([destmac,pexpect.EOF,pexpect.TIMEOUT])
-            main.log.info(self.name+": ARP successful")
-            self.handle.expect(["mininet",pexpect.EOF,pexpect.TIMEOUT])
+            self.handle.expect( [ destmac, pexpect.EOF, pexpect.TIMEOUT ] )
+            main.log.info( self.name + ": ARP successful" )
+            self.handle.expect( [ "mininet", pexpect.EOF, pexpect.TIMEOUT ] )
             return main.TRUE
         except:
-            main.log.warn(self.name+": ARP FAILURE")
-            self.handle.expect(["mininet",pexpect.EOF,pexpect.TIMEOUT])
+            main.log.warn( self.name + ": ARP FAILURE" )
+            self.handle.expect( [ "mininet", pexpect.EOF, pexpect.TIMEOUT ] )
             return main.FALSE
 
-    def decToHex(num):
-        return hex(num).split('x')[1]
-    
-    def getSwitchFlowCount(self, switch):
-        '''
-        return the Flow Count of the switch
-        '''
+    def decToHex( self, num ):
+        return hex( num ).split( 'x' )[ 1 ]
+
+    def getSwitchFlowCount( self, switch ):
+        """
+           return the Flow Count of the switch"""
         if self.handle:
             cmd = "sh ovs-ofctl dump-aggregate %s" % switch
             try:
-                response = self.execute(cmd=cmd, prompt="mininet>", timeout=10)
+                response = self.execute(
+                    cmd=cmd,
+                    prompt="mininet>",
+                    timeout=10 )
             except pexpect.EOF:
-                main.log.error(self.name + ": EOF exception found")
-                main.log.error(self.name + "     " + self.handle.before)
+                main.log.error( self.name + ": EOF exception found" )
+                main.log.error( self.name + "     " + self.handle.before )
                 main.cleanup()
                 main.exit()
             pattern = "flow_count=(\d+)"
-            result = re.search(pattern, response, re.MULTILINE)
+            result = re.search( pattern, response, re.MULTILINE )
             if result is None:
-                main.log.info("Couldn't find flows on switch '', found: %s" % (switch, response))
+                main.log.info(
+                    "Couldn't find flows on switch %s, found: %s" %
+                    ( switch, response ) )
                 return main.FALSE
-            return result.group(1)
+            return result.group( 1 )
         else:
-            main.log.error("Connection failed to the Mininet host")
-    
-    def check_flows(self, sw, dump_format=None):
+            main.log.error( "Connection failed to the Mininet host" )
+
+    def check_flows( self, sw, dump_format=None ):
         if dump_format:
-          command = "sh ovs-ofctl -F " + dump_format + " dump-flows " + str(sw)
+            command = "sh ovs-ofctl -F " + \
+                dump_format + " dump-flows " + str( sw )
         else:
-          command = "sh ovs-ofctl dump-flows "+str(sw)
+            command = "sh ovs-ofctl dump-flows " + str( sw )
         try:
-            response=self.execute(cmd=command,prompt="mininet>",timeout=10)
+            response = self.execute(
+                cmd=command,
+                prompt="mininet>",
+                timeout=10 )
             return response
         except pexpect.EOF:
-            main.log.error(self.name + ": EOF exception found")
-            main.log.error(self.name + ":     " + self.handle.before)
+            main.log.error( self.name + ": EOF exception found" )
+            main.log.error( self.name + ":     " + self.handle.before )
             main.cleanup()
             main.exit()
         else:
-            main.log.info(response)
+            main.log.info( response )
 
-    def start_tcpdump(self, filename, intf = "eth0", port = "port 6633"):
-        '''
-        Runs tpdump on an intferface and saves the file
-        intf can be specified, or the default eth0 is used
-        '''
+    def start_tcpdump( self, filename, intf="eth0", port="port 6633" ):
+        """
+           Runs tpdump on an intferface and saves the file
+           intf can be specified, or the default eth0 is used"""
         try:
-            self.handle.sendline("")
-            self.handle.expect("mininet>")
-            self.handle.sendline("sh sudo tcpdump -n -i "+ intf + " " + port + " -w " + filename.strip() + "  &")
-            self.handle.sendline("")
-            i=self.handle.expect(['No\ssuch\device','listening\son',pexpect.TIMEOUT,"mininet>"],timeout=10)
-            main.log.warn(self.handle.before + self.handle.after)
-            self.handle.sendline("")
-            self.handle.expect("mininet>")
+            self.handle.sendline( "" )
+            self.handle.expect( "mininet>" )
+            self.handle.sendline(
+                "sh sudo tcpdump -n -i " +
+                intf +
+                " " +
+                port +
+                " -w " +
+                filename.strip() +
+                "  &" )
+            self.handle.sendline( "" )
+            i = self.handle.expect( [ 'No\ssuch\device',
+                                      'listening\son',
+                                      pexpect.TIMEOUT,
+                                      "mininet>" ],
+                                    timeout=10 )
+            main.log.warn( self.handle.before + self.handle.after )
+            self.handle.sendline( "" )
+            self.handle.expect( "mininet>" )
             if i == 0:
-                main.log.error(self.name + ": tcpdump - No such device exists. tcpdump attempted on: " + intf)
+                main.log.error(
+                    self.name +
+                    ": tcpdump - No such device exists. " +
+                    "tcpdump attempted on: " +
+                    intf )
                 return main.FALSE
             elif i == 1:
-                main.log.info(self.name + ": tcpdump started on " + intf)
+                main.log.info( self.name + ": tcpdump started on " + intf )
                 return main.TRUE
             elif i == 2:
-                main.log.error(self.name + ": tcpdump command timed out! Check interface name, given interface was: " + intf)
+                main.log.error(
+                    self.name +
+                    ": tcpdump command timed out! Check interface name," +
+                    " given interface was: " +
+                    intf )
                 return main.FALSE
-            elif i ==3: 
-                main.log.info(self.name +": " +  self.handle.before)
+            elif i == 3:
+                main.log.info( self.name + ": " + self.handle.before )
                 return main.TRUE
             else:
-                main.log.error(self.name + ": tcpdump - unexpected response")
+                main.log.error( self.name + ": tcpdump - unexpected response" )
             return main.FALSE
         except pexpect.EOF:
-            main.log.error(self.name + ": EOF exception found")
-            main.log.error(self.name + ":     " + self.handle.before)
+            main.log.error( self.name + ": EOF exception found" )
+            main.log.error( self.name + ":     " + self.handle.before )
             main.cleanup()
             main.exit()
         except:
-            main.log.info(self.name + ":::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::")
+            main.log.info( self.name + ":" * 50 )
             main.log.error( traceback.print_exc() )
-            main.log.info(":::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::")
+            main.log.info(":" * 50 )
             main.cleanup()
             main.exit()
 
-    def stop_tcpdump(self):
+    def stop_tcpdump( self ):
         "pkills tcpdump"
         try:
-            self.handle.sendline("sh sudo pkill tcpdump")
-            self.handle.expect("mininet>")
-            self.handle.sendline("")
-            self.handle.expect("mininet>")
+            self.handle.sendline( "sh sudo pkill tcpdump" )
+            self.handle.expect( "mininet>" )
+            self.handle.sendline( "" )
+            self.handle.expect( "mininet>" )
         except pexpect.EOF:
-            main.log.error(self.name + ": EOF exception found")
-            main.log.error(self.name + ":     " + self.handle.before)
+            main.log.error( self.name + ": EOF exception found" )
+            main.log.error( self.name + ":     " + self.handle.before )
             main.cleanup()
             main.exit()
         except:
-            main.log.info(self.name + ":::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::")
+            main.log.info( self.name + ":" * 50 )
             main.log.error( traceback.print_exc() )
-            main.log.info(":::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::")
+            main.log.info(":" * 50 )
             main.cleanup()
             main.exit()
 
-    def compare_switches(self, topo, switches_json):
-        '''
-        Compare mn and onos switches
-        topo: sts TestONTopology object
-        switches_json: parsed json object from the onos devices api
+    def compare_switches( self, topo, switches_json ):
+        """
+           Compare mn and onos switches
+           topo: sts TestONTopology object
+            switches_json: parsed json object from the onos devices api
 
-        This uses the sts TestONTopology object
-
-        '''
-        import json
-        #main.log.debug("Switches_json string: ", switches_json)
-        output = {"switches":[]}
-        for switch in topo.graph.switches: #iterate through the MN topology and pull out switches and and port info
+           This uses the sts TestONTopology object"""
+        # main.log.debug( "Switches_json string: ", switches_json )
+        output = { "switches": [] }
+        # iterate through the MN topology and pull out switches and and port
+        # info
+        for switch in topo.graph.switches:
             ports = []
             for port in switch.ports.values():
-                ports.append({'of_port': port.port_no, 'mac': str(port.hw_addr).replace('\'',''), 'name': port.name})
-            output['switches'].append({"name": switch.name, "dpid": str(switch.dpid).zfill(16), "ports": ports })
+                ports.append( { 'of_port': port.port_no,
+                                'mac': str( port.hw_addr ).replace( '\'',
+                                                                    ''),
+                                'name': port.name } )
+            output[ 'switches' ].append( {
+                "name": switch.name,
+                "dpid": str( switch.dpid ).zfill( 16 ),
+                "ports": ports } )
 
-        #print "mn"
-        #print json.dumps(output, sort_keys=True,indent=4,separators=(',', ': '))
-        #print "onos"
-        #print json.dumps(switches_json, sort_keys=True,indent=4,separators=(',', ': '))
-
+        # print "mn"
+        # print json.dumps( output,
+        #                   sort_keys=True,
+        #                   indent=4,
+        #                   separators=( ',', ': ' ) )
+        # print "onos"
+        # print json.dumps( switches_json,
+        #                   sort_keys=True,
+        #                   indent=4,
+        #                   separators=( ',', ': ' ) )
 
         # created sorted list of dpid's in MN and ONOS for comparison
-        mnDPIDs=[]
-        for switch in output['switches']:
-            mnDPIDs.append(switch['dpid'].lower())
+        mnDPIDs = []
+        for switch in output[ 'switches' ]:
+            mnDPIDs.append( switch[ 'dpid' ].lower() )
         mnDPIDs.sort()
-        #print "List of Mininet switch DPID's"
-        #print mnDPIDs
-        if switches_json == "":#if rest call fails
-            main.log.error(self.name + ".compare_switches(): Empty JSON object given from ONOS")
+        # print "List of Mininet switch DPID's"
+        # print mnDPIDs
+        if switches_json == "":  # if rest call fails
+            main.log.error(
+                self.name +
+                ".compare_switches(): Empty JSON object given from ONOS" )
             return main.FALSE
-        onos=switches_json
-        onosDPIDs=[]
+        onos = switches_json
+        onosDPIDs = []
         for switch in onos:
-            if switch['available'] == True:
-                onosDPIDs.append(switch['id'].replace(":",'').replace("of",'').lower())
-            #else:
-                #print "Switch is unavailable:"
-                #print switch
+            if switch[ 'available' ]:
+                onosDPIDs.append(
+                    switch[ 'id' ].replace(
+                        ":",
+                        '' ).replace(
+                        "of",
+                        '' ).lower() )
+            # else:
+                # print "Switch is unavailable:"
+                # print switch
         onosDPIDs.sort()
-        #print "List of ONOS switch DPID's"
-        #print onosDPIDs
+        # print "List of ONOS switch DPID's"
+        # print onosDPIDs
 
-        if mnDPIDs!=onosDPIDs:
+        if mnDPIDs != onosDPIDs:
             switch_results = main.FALSE
-            main.log.report( "Switches in MN but not in ONOS:")
-            main.log.report( str([switch for switch in mnDPIDs if switch not in onosDPIDs]))
-            main.log.report( "Switches in ONOS but not in MN:")
-            main.log.report(  str([switch for switch in onosDPIDs if switch not in mnDPIDs]))
-        else:#list of dpid's match in onos and mn
-            #main.log.report("DEBUG: The dpid's of the switches in Mininet and ONOS match")
+            main.log.report( "Switches in MN but not in ONOS:" )
+            list1 = [ switch for switch in mnDPIDs if switch not in onosDPIDs ]
+            main.log.report( str( list1 ) )
+            main.log.report( "Switches in ONOS but not in MN:" )
+            list2 = [ switch for switch in onosDPIDs if switch not in mnDPIDs ]
+            main.log.report(str( list2 ) )
+        else:  # list of dpid's match in onos and mn
             switch_results = main.TRUE
         return switch_results
 
-
-
-    def compare_ports(self, topo, ports_json):
-        '''
+    def compare_ports( self, topo, ports_json ):
+        """
         Compare mn and onos ports
         topo: sts TestONTopology object
         ports_json: parsed json object from the onos ports api
 
-        Dependencies: 
+        Dependencies:
             1. This uses the sts TestONTopology object
             2. numpy - "sudo pip install numpy"
 
-        '''
-        #FIXME: this does not look for extra ports in ONOS, only checks that ONOS has what is in MN
-        import json
+        """
+        # FIXME: this does not look for extra ports in ONOS, only checks that
+        # ONOS has what is in MN
         from numpy import uint64
         ports_results = main.TRUE
-        output = {"switches":[]}
-        for switch in topo.graph.switches: #iterate through the MN topology and pull out switches and and port info
+        output = { "switches": [] }
+        # iterate through the MN topology and pull out switches and and port
+        # info
+        for switch in topo.graph.switches:
             ports = []
             for port in switch.ports.values():
-                #print port.hw_addr.toStr(separator = '')
+                # print port.hw_addr.toStr( separator='' )
                 tmp_port = {}
-                tmp_port['of_port'] = port.port_no
-                tmp_port['mac'] = str(port.hw_addr).replace('\'','')
-                tmp_port['name'] = port.name
-                tmp_port['enabled'] = port.enabled
+                tmp_port[ 'of_port' ] = port.port_no
+                tmp_port[ 'mac' ] = str( port.hw_addr ).replace( '\'', '' )
+                tmp_port[ 'name' ] = port.name
+                tmp_port[ 'enabled' ] = port.enabled
 
-                ports.append(tmp_port)
+                ports.append( tmp_port )
             tmp_switch = {}
-            tmp_switch['name'] = switch.name
-            tmp_switch['dpid'] = str(switch.dpid).zfill(16)
-            tmp_switch['ports'] = ports
+            tmp_switch[ 'name' ] = switch.name
+            tmp_switch[ 'dpid' ] = str( switch.dpid ).zfill( 16 )
+            tmp_switch[ 'ports' ] = ports
 
-            output['switches'].append(tmp_switch)
+            output[ 'switches' ].append( tmp_switch )
 
-
-        ################ports#############
-        for mn_switch in output['switches']:
+        # PORTS
+        for mn_switch in output[ 'switches' ]:
             mn_ports = []
             onos_ports = []
             switch_result = main.TRUE
-            for port in mn_switch['ports']:
-                if port['enabled'] == True:
-                    mn_ports.append(port['of_port'])
-                #else: #DEBUG only 
-                #    main.log.warn("Port %s on switch %s is down" % ( str(port['of_port']) , str(mn_switch['name'])) )
+            for port in mn_switch[ 'ports' ]:
+                if port[ 'enabled' ]:
+                    mn_ports.append( port[ 'of_port' ] )
             for onos_switch in ports_json:
-                #print "Iterating through a new switch as seen by ONOS"
-                #print onos_switch
-                if onos_switch['device']['available'] == True:
-                    if onos_switch['device']['id'].replace(':','').replace("of", '') == mn_switch['dpid']:
-                        for port in onos_switch['ports']:
-                            if port['isEnabled']:
-                                #print "Iterating through available ports on the switch"
-                                #print port
-                                if port['port'] == 'local':
-                                    #onos_ports.append('local')
-                                    onos_ports.append(long(uint64(-2)))
+                # print "Iterating through a new switch as seen by ONOS"
+                # print onos_switch
+                if onos_switch[ 'device' ][ 'available' ]:
+                    if onos_switch[ 'device' ][ 'id' ].replace(
+                            ':',
+                            '' ).replace(
+                            "of",
+                            '' ) == mn_switch[ 'dpid' ]:
+                        for port in onos_switch[ 'ports' ]:
+                            if port[ 'isEnabled' ]:
+                                if port[ 'port' ] == 'local':
+                                    # onos_ports.append( 'local' )
+                                    onos_ports.append( long( uint64( -2 ) ) )
                                 else:
-                                    onos_ports.append(int(port['port']))
-                                    '''
-                                else: #This is likely a new reserved port implemented
-                                    main.log.error("unkown port '" + str(port['port']) )
-                                    '''
-                           #else: #DEBUG
-                           #    main.log.warn("Port %s on switch %s is down" % ( str(port['port']) , str(onos_switch['device']['id'])) )
+                                    onos_ports.append( int( port[ 'port' ] ) )
                         break
-            mn_ports.sort(key=float)
-            onos_ports.sort(key=float)
-            #print "\nPorts for Switch %s:" % (mn_switch['name'])
-            #print "\tmn_ports[] = ", mn_ports
-            #print "\tonos_ports[] = ", onos_ports
+            mn_ports.sort( key=float )
+            onos_ports.sort( key=float )
+            # print "\nPorts for Switch %s:" % ( mn_switch[ 'name' ] )
+            # print "\tmn_ports[] = ", mn_ports
+            # print "\tonos_ports[] = ", onos_ports
             mn_ports_log = mn_ports
             onos_ports_log = onos_ports
-            mn_ports = [x for x in mn_ports]
-            onos_ports = [x for x in onos_ports]
+            mn_ports = [ x for x in mn_ports ]
+            onos_ports = [ x for x in onos_ports ]
 
-            #TODO: handle other reserved port numbers besides LOCAL
-            #NOTE: Reserved ports
-            #   Local port: -2 in Openflow, ONOS shows 'local', we store as long(uint64(-2))
+            # TODO: handle other reserved port numbers besides LOCAL
+            # NOTE: Reserved ports
+            # Local port: -2 in Openflow, ONOS shows 'local', we store as
+            # long( uint64( -2 ) )
             for mn_port in mn_ports_log:
                 if mn_port in onos_ports:
-                    #don't set results to true here as this is just one of many checks and it might override a failure
-                    mn_ports.remove(mn_port)
-                    onos_ports.remove(mn_port)
-                #NOTE: OVS reports this as down since there is no link
+                    # don't set results to true here as this is just one of
+                    # many checks and it might override a failure
+                    mn_ports.remove( mn_port )
+                    onos_ports.remove( mn_port )
+                # NOTE: OVS reports this as down since there is no link
                 #      So ignoring these for now
-                #TODO: Come up with a better way of handling these
+                # TODO: Come up with a better way of handling these
                 if 65534 in mn_ports:
-                    mn_ports.remove(65534)
-                if long(uint64(-2)) in onos_ports:
-                    onos_ports.remove( long(uint64(-2))  )
-            if len(mn_ports):  #the ports of this switch don't match
+                    mn_ports.remove( 65534 )
+                if long( uint64( -2 ) ) in onos_ports:
+                    onos_ports.remove( long( uint64( -2 ) ) )
+            if len( mn_ports ):  # the ports of this switch don't match
                 switch_result = main.FALSE
-                main.log.warn("Ports in MN but not ONOS: " + str(mn_ports) )
-            if len(onos_ports):  #the ports of this switch don't match
+                main.log.warn( "Ports in MN but not ONOS: " + str( mn_ports ) )
+            if len( onos_ports ):  # the ports of this switch don't match
                 switch_result = main.FALSE
-                main.log.warn("Ports in ONOS but not MN: " + str(onos_ports) )
+                main.log.warn(
+                    "Ports in ONOS but not MN: " +
+                    str( onos_ports ) )
             if switch_result == main.FALSE:
-                main.log.report("The list of ports for switch %s(%s) does not match:" % (mn_switch['name'], mn_switch['dpid']) )
-                main.log.warn("mn_ports[]  =  " + str(mn_ports_log))
-                main.log.warn("onos_ports[] = " + str(onos_ports_log))
+                main.log.report(
+                    "The list of ports for switch %s(%s) does not match:" %
+                    ( mn_switch[ 'name' ], mn_switch[ 'dpid' ] ) )
+                main.log.warn( "mn_ports[]  =  " + str( mn_ports_log ) )
+                main.log.warn( "onos_ports[] = " + str( onos_ports_log ) )
             ports_results = ports_results and switch_result
         return ports_results
 
+    def compare_links( self, topo, links_json ):
+        """
+           Compare mn and onos links
+           topo: sts TestONTopology object
+           links_json: parsed json object from the onos links api
 
-
-
-    def compare_links(self, topo, links_json):
-        '''
-        Compare mn and onos links
-        topo: sts TestONTopology object
-        links_json: parsed json object from the onos links api
-
-        This uses the sts TestONTopology object
-
-        '''
-        #FIXME: this does not look for extra links in ONOS, only checks that ONOS has what is in MN
-        import json
+           This uses the sts TestONTopology object"""
+        # FIXME: this does not look for extra links in ONOS, only checks that
+        # ONOS has what is in MN
         link_results = main.TRUE
-        output = {"switches":[]}
+        output = { "switches": [] }
         onos = links_json
-        for switch in topo.graph.switches: #iterate through the MN topology and pull out switches and and port info
+        # iterate through the MN topology and pull out switches and and port
+        # info
+        for switch in topo.graph.switches:
             # print "Iterating though switches as seen by Mininet"
             # print switch
             ports = []
             for port in switch.ports.values():
-                #print port.hw_addr.toStr(separator = '')
-                ports.append({'of_port': port.port_no, 'mac': str(port.hw_addr).replace('\'',''), 'name': port.name})
-            output['switches'].append({"name": switch.name, "dpid": str(switch.dpid).zfill(16), "ports": ports })
-        #######Links########
+                # print port.hw_addr.toStr( separator='' )
+                ports.append( { 'of_port': port.port_no,
+                                'mac': str( port.hw_addr ).replace( '\'',
+                                                                    ''),
+                                'name': port.name } )
+            output[ 'switches' ].append( {
+                "name": switch.name,
+                "dpid": str( switch.dpid ).zfill( 16 ),
+                "ports": ports } )
+        # LINKS
 
-        mn_links = [link for link in topo.patch_panel.network_links if (link.port1.enabled and link.port2.enabled)]
-        #print "mn_links:"
-        #print mn_links
-        if 2*len(mn_links) == len(onos):
+        mn_links = [
+            link for link in topo.patch_panel.network_links if (
+                link.port1.enabled and link.port2.enabled ) ]
+        if 2 * len( mn_links ) == len( onos ):
             link_results = main.TRUE
         else:
             link_results = main.FALSE
-            main.log.report("Mininet has %i bidirectional links and ONOS has %i unidirectional links" % (len(mn_links), len(onos) ))
+            main.log.report(
+                "Mininet has %i bidirectional links and " +
+                "ONOS has %i unidirectional links" %
+                ( len( mn_links ), len( onos ) ) )
 
-
-        # iterate through MN links and check if an ONOS link exists in both directions
-        # NOTE: Will currently only show mn links as down if they are cut through STS. 
-        #       We can either do everything through STS or wait for up_network_links 
-        #       and down_network_links to be fully implemented.
-        for link in mn_links: 
-            #print "Link: %s" % link
-            #TODO: Find a more efficient search method
+        # iterate through MN links and check if an ONOS link exists in
+        # both directions
+        # NOTE: Will currently only show mn links as down if they are
+        #       cut through STS. We can either do everything through STS or
+        #       wait for up_network_links and down_network_links to be
+        #       fully implemented.
+        for link in mn_links:
+            # print "Link: %s" % link
+            # TODO: Find a more efficient search method
             node1 = None
             port1 = None
             node2 = None
             port2 = None
             first_dir = main.FALSE
             second_dir = main.FALSE
-            for switch in output['switches']:
-                #print "Switch: %s" % switch['name']
-                if switch['name'] == link.node1.name:
-                    node1 = switch['dpid']
-                    for port in switch['ports']:
-                        if str(port['name']) == str(link.port1):
-                            port1 = port['of_port'] 
+            for switch in output[ 'switches' ]:
+                # print "Switch: %s" % switch[ 'name' ]
+                if switch[ 'name' ] == link.node1.name:
+                    node1 = switch[ 'dpid' ]
+                    for port in switch[ 'ports' ]:
+                        if str( port[ 'name' ] ) == str( link.port1 ):
+                            port1 = port[ 'of_port' ]
                     if node1 is not None and node2 is not None:
                         break
-                if switch['name'] == link.node2.name:
-                    node2 = switch['dpid']
-                    for port in switch['ports']: 
-                        if str(port['name']) == str(link.port2):
-                            port2 = port['of_port'] 
+                if switch[ 'name' ] == link.node2.name:
+                    node2 = switch[ 'dpid' ]
+                    for port in switch[ 'ports' ]:
+                        if str( port[ 'name' ] ) == str( link.port2 ):
+                            port2 = port[ 'of_port' ]
                     if node1 is not None and node2 is not None:
                         break
 
-
             for onos_link in onos:
-                onos_node1 = onos_link['src']['device'].replace(":",'').replace("of", '')
-                onos_node2 = onos_link['dst']['device'].replace(":",'').replace("of", '')
-                onos_port1 = onos_link['src']['port']
-                onos_port2 = onos_link['dst']['port']
+                onos_node1 = onos_link[ 'src' ][ 'device' ].replace(
+                    ":",
+                    '' ).replace(
+                    "of",
+                    '' )
+                onos_node2 = onos_link[ 'dst' ][ 'device' ].replace(
+                    ":",
+                    '' ).replace(
+                    "of",
+                    '' )
+                onos_port1 = onos_link[ 'src' ][ 'port' ]
+                onos_port2 = onos_link[ 'dst' ][ 'port' ]
 
-                #print "Checking ONOS for link %s/%s -> %s/%s and" % (node1, port1, node2, port2)
-                #print "Checking ONOS for link %s/%s -> %s/%s" % (node2, port2, node1, port1)
                 # check onos link from node1 to node2
-                if str(onos_node1) == str(node1) and str(onos_node2) == str(node2):
-                    if int(onos_port1) == int(port1) and int(onos_port2) == int(port2):
+                if str( onos_node1 ) == str( node1 ) and str(
+                        onos_node2 ) == str( node2 ):
+                    if int( onos_port1 ) == int( port1 ) and int(
+                            onos_port2 ) == int( port2 ):
                         first_dir = main.TRUE
                     else:
-                        main.log.warn('The port numbers do not match for ' +str(link) +\
-                                ' between ONOS and MN. When cheking ONOS for link '+\
-                                '%s/%s -> %s/%s' % (node1, port1, node2, port2)+\
-                                ' ONOS has the values %s/%s -> %s/%s' %\
-                                (onos_node1, onos_port1, onos_node2, onos_port2))
+                        main.log.warn(
+                            'The port numbers do not match for ' +
+                            str( link ) +
+                            ' between ONOS and MN. When cheking ONOS for ' +
+                            'link %s/%s -> %s/%s' %
+                            ( node1,
+                              port1,
+                              node2,
+                              port2 ) +
+                            ' ONOS has the values %s/%s -> %s/%s' %
+                            ( onos_node1,
+                              onos_port1,
+                              onos_node2,
+                              onos_port2 ) )
 
                 # check onos link from node2 to node1
-                elif ( str(onos_node1) == str(node2) and str(onos_node2) == str(node1) ):
-                    if ( int(onos_port1) == int(port2) and int(onos_port2) == int(port1) ):
+                elif ( str( onos_node1 ) == str( node2 ) and
+                        str( onos_node2 ) == str( node1 ) ):
+                    if ( int( onos_port1 ) == int( port2 )
+                         and int( onos_port2 ) == int( port1 ) ):
                         second_dir = main.TRUE
                     else:
-                        main.log.warn('The port numbers do not match for ' +str(link) +\
-                                ' between ONOS and MN. When cheking ONOS for link '+\
-                                '%s/%s -> %s/%s' % (node2, port2, node1, port1)+\
-                                ' ONOS has the values %s/%s -> %s/%s' %\
-                                (onos_node2, onos_port2, onos_node1, onos_port1))
-                else:#this is not the link you're looking for
+                        main.log.warn(
+                            'The port numbers do not match for ' +
+                            str( link ) +
+                            ' between ONOS and MN. When cheking ONOS for ' +
+                            'link %s/%s -> %s/%s' %
+                            ( node2,
+                              port2,
+                              node1,
+                              port1 ) +
+                            ' ONOS has the values %s/%s -> %s/%s' %
+                            ( onos_node2,
+                              onos_port2,
+                              onos_node1,
+                              onos_port1 ) )
+                else:  # this is not the link you're looking for
                     pass
             if not first_dir:
-                main.log.report('ONOS does not have the link %s/%s -> %s/%s' % (node1, port1, node2, port2))
+                main.log.report(
+                    'ONOS does not have the link %s/%s -> %s/%s' %
+                    ( node1, port1, node2, port2 ) )
             if not second_dir:
-                main.log.report('ONOS does not have the link %s/%s -> %s/%s' % (node2, port2, node1, port1))
+                main.log.report(
+                    'ONOS does not have the link %s/%s -> %s/%s' %
+                    ( node2, port2, node1, port1 ) )
             link_results = link_results and first_dir and second_dir
         return link_results
 
+    def get_hosts( self ):
+        """
+           Returns a list of all hosts
+           Don't ask questions just use it"""
+        self.handle.sendline( "" )
+        self.handle.expect( "mininet>" )
 
-    def get_hosts(self):
-        '''
-        Returns a list of all hosts
-        Don't ask questions just use it
-        '''
-        self.handle.sendline("")
-        self.handle.expect("mininet>")
-        
-        self.handle.sendline("py [ host.name for host in net.hosts ]")
-        self.handle.expect("mininet>")
+        self.handle.sendline( "py [ host.name for host in net.hosts ]" )
+        self.handle.expect( "mininet>" )
 
         handle_py = self.handle.before
-        handle_py = handle_py.split("]\r\n",1)[1]
+        handle_py = handle_py.split( "]\r\n", 1 )[ 1 ]
         handle_py = handle_py.rstrip()
 
-        self.handle.sendline("")
-        self.handle.expect("mininet>")
+        self.handle.sendline( "" )
+        self.handle.expect( "mininet>" )
 
-        host_str = handle_py.replace("]", "")
-        host_str = host_str.replace("'", "")
-        host_str = host_str.replace("[", "")
-        host_list = host_str.split(",")
+        host_str = handle_py.replace( "]", "" )
+        host_str = host_str.replace( "'", "" )
+        host_str = host_str.replace( "[", "" )
+        host_list = host_str.split( "," )
 
-        return host_list 
+        return host_list
 
-
-    def update(self):
-        '''
-        updates the port address and status information for each port in mn
-        '''
-        #TODO: Add error checking. currently the mininet command has no output
-        main.log.info("Updateing MN port information")
+    def update( self ):
+        """
+           updates the port address and status information for
+           each port in mn"""
+        # TODO: Add error checking. currently the mininet command has no output
+        main.log.info( "Updateing MN port information" )
         try:
-            self.handle.sendline("")
-            self.handle.expect("mininet>")
+            self.handle.sendline( "" )
+            self.handle.expect( "mininet>" )
 
-            self.handle.sendline("update")
-            self.handle.expect("update")
-            self.handle.expect("mininet>")
+            self.handle.sendline( "update" )
+            self.handle.expect( "update" )
+            self.handle.expect( "mininet>" )
 
-            self.handle.sendline("")
-            self.handle.expect("mininet>")
+            self.handle.sendline( "" )
+            self.handle.expect( "mininet>" )
 
             return main.TRUE
         except pexpect.EOF:
-            main.log.error(self.name + ": EOF exception found")
-            main.log.error(self.name + ":     " + self.handle.before)
+            main.log.error( self.name + ": EOF exception found" )
+            main.log.error( self.name + ":     " + self.handle.before )
             main.cleanup()
             main.exit()
 
 if __name__ != "__main__":
     import sys
-    sys.modules[__name__] = MininetCliDriver()
-
+    sys.modules[ __name__ ] = MininetCliDriver()
diff --git a/TestON/drivers/common/cli/emulator/remotemininetdriver.py b/TestON/drivers/common/cli/emulator/remotemininetdriver.py
index ae0f599..48d3389 100644
--- a/TestON/drivers/common/cli/emulator/remotemininetdriver.py
+++ b/TestON/drivers/common/cli/emulator/remotemininetdriver.py
@@ -16,30 +16,23 @@
     GNU General Public License for more details.
 
     You should have received a copy of the GNU General Public License
-    along with TestON.  If not, see <http://www.gnu.org/licenses/>.		
+    along with TestON.  If not, see <http://www.gnu.org/licenses/>.
 
 
 MininetCliDriver is the basic driver which will handle the Mininet functions
 '''
 import traceback
 import pexpect
-import struct
-import fcntl
-import os
-import signal
 import re
 import sys
-import core.teston
 sys.path.append("../")
 from drivers.common.cli.emulatordriver import Emulator
-from drivers.common.clidriver import CLI
-from time import time
 
 class RemoteMininetDriver(Emulator):
     '''
     RemoteMininetCliDriver is the basic driver which will handle the Mininet functions
-    The main different between this and the MininetCliDriver is that this one does not build the mininet. 
-    It assumes that there is already a mininet running on the target. 
+    The main different between this and the MininetCliDriver is that this one does not build the mininet.
+    It assumes that there is already a mininet running on the target.
     '''
     def __init__(self):
         super(Emulator, self).__init__()
@@ -51,25 +44,25 @@
         #,user_name, ip_address, pwd,options):
         # Here the main is the TestON instance after creating all the log handles.
         for key in connectargs:
-            vars(self)[key] = connectargs[key]       
-        
+            vars(self)[key] = connectargs[key]
+
         self.name = self.options['name']
         self.handle = super(RemoteMininetDriver, self).connect(user_name = self.user_name, ip_address = self.ip_address,port = None, pwd = self.pwd)
-        
+
         self.ssh_handle = self.handle
-        
-        # Copying the readme file to process the 
+
+        # Copying the readme file to process the
         if self.handle :
             return main.TRUE
 
         else :
-            main.log.error("Connection failed to the host "+self.user_name+"@"+self.ip_address) 
+            main.log.error("Connection failed to the host "+self.user_name+"@"+self.ip_address)
             main.log.error("Failed to connect to the Mininet")
             return main.FALSE
 
 #*********************************************************************************************
 #*********************************************************************************************
-# checkForLoss will determine if any of the pings had any packets lost during the course of 
+# checkForLoss will determine if any of the pings had any packets lost during the course of
 # the pingLong.
 #*********************************************************************************************
 #*********************************************************************************************
@@ -84,7 +77,6 @@
         #EX: 393 packets transmitted, 380 received, 3% packet loss, time 78519ms
         # we may need to return a float to get around rounding errors
 
-        import os
         self.handle.sendline("")
         self.handle.expect("\$")
         #Clear any output waiting in the bg from killing pings
@@ -107,7 +99,7 @@
 
     def pingLong(self,**pingParams):
         '''
-        Starts a continuous ping on the mininet host outputing to a file in the /tmp dir. 
+        Starts a continuous ping on the mininet host outputing to a file in the /tmp dir.
         '''
         self.handle.sendline("")
         self.handle.expect("\$")
@@ -115,7 +107,7 @@
         precmd = "sudo rm /tmp/ping." + args["SRC"]
         self.execute(cmd=precmd,prompt="(.*)",timeout=10)
         command = "sudo mininet/util/m " + args["SRC"] + " ping "+args ["TARGET"]+" -i .2 -w " + str(args['PINGTIME']) + " -D > /tmp/ping." + args["SRC"] + " &"
-        main.log.info( command ) 
+        main.log.info( command )
         self.execute(cmd=command,prompt="(.*)",timeout=10)
         self.handle.sendline("")
         self.handle.expect("\$")
@@ -135,33 +127,28 @@
         self.handle.sendline("")
         self.handle.expect("\$")
         if re.search('Unreachable', result ):
-            main.log.info("Unreachable found in ping logs...") 
+            main.log.info("Unreachable found in ping logs...")
             return main.FALSE
-        elif re.search('64\sbytes', result): 
-            main.log.info("Pings look good") 
+        elif re.search('64\sbytes', result):
+            main.log.info("Pings look good")
             return main.TRUE
-        else: 
-            main.log.info("No, or faulty ping data...") 
+        else:
+            main.log.info("No, or faulty ping data...")
             return main.FALSE
-         
+
     def pingKill(self, testONUser, testONIP):
         '''
         Kills all continuous ping processes.
         Then copies all the ping files to the TestStation.
         '''
-        import time
         self.handle.sendline("")
         self.handle.expect("\$")
-        command = "sudo kill -SIGINT `pgrep ping`" 
-        main.log.info( command ) 
+        command = "sudo kill -SIGINT `pgrep ping`"
+        main.log.info( command )
         self.execute(cmd=command,prompt="(.*)",timeout=10)
-        #Commenting out in case TestON and MN are on the same machine. scp overrights the file anyways
-        #main.log.info( "Removing old ping data" )
-        #command = "rm /tmp/ping.*"
-        #os.popen(command) 
-        #time.sleep(2)      
+
         main.log.info( "Transferring ping files to TestStation" )
-        command = "scp /tmp/ping.* "+ str(testONUser) + "@" + str(testONIP) + ":/tmp/" 
+        command = "scp /tmp/ping.* "+ str(testONUser) + "@" + str(testONIP) + ":/tmp/"
         self.execute(cmd=command,prompt="100%",timeout=20)
         #Make sure the output is cleared
         self.handle.sendline("")
@@ -176,9 +163,8 @@
             return main.FALSE
         else:
             return main.TRUE
-    
+
     def pingLongKill(self):
-        import time
         self.handle.sendline("")
         self.handle.expect("\$")
         command = "sudo kill -SIGING `pgrep ping`"
@@ -187,7 +173,7 @@
         self.handle.sendline("")
         self.handle.expect("\$")
         return main.TRUE
-       
+
     def pingHostOptical(self,**pingParams):
         '''
         This function is only for Packey Optical related ping
@@ -228,31 +214,31 @@
             return main.FALSE
 
     def pingHost(self,**pingParams):
-        ''' 
-        Pings between two hosts on remote mininet  
-        ''' 
+        '''
+        Pings between two hosts on remote mininet
+        '''
         self.handle.sendline("")
         self.handle.expect("\$")
         args = utilities.parse_args(["SRC","TARGET"],**pingParams)
         #command = "mininet/util/m " + args["SRC"] + " ping "+args ["TARGET"]+" -c 4 -W 1 -i .2"
         command = "mininet/util/m " + args["SRC"] + " ping "+args ["TARGET"]+" -c 4 -W 1 -i .2"
-        main.log.info ( command ) 
+        main.log.info ( command )
         response = self.execute(cmd=command,prompt="rtt",timeout=10 )
         #self.handle.sendline("")
         #self.handle.expect("\$")
         if utilities.assert_matches(expect=',\s0\%\spacket\sloss',actual=response,onpass="No Packet loss",onfail="Host is not reachable"):
             main.log.info("NO PACKET LOSS, HOST IS REACHABLE")
-            main.last_result = main.TRUE 
+            main.last_result = main.TRUE
             return main.TRUE
         else :
             main.log.error("PACKET LOST, HOST IS NOT REACHABLE")
             main.last_result = main.FALSE
             return main.FALSE
-        
-    
+
+
     def checknum(self,num):
         '''
-        Verifies the correct number of switches are running 
+        Verifies the correct number of switches are running
         '''
         if self.handle :
             self.handle.sendline("")
@@ -261,7 +247,7 @@
             self.handle.expect("wc")
             self.handle.expect("\$")
             response = self.handle.before
-            self.handle.sendline('ps -ef | grep "bash -ms mininet:sw" | grep -v color | wc -l') 
+            self.handle.sendline('ps -ef | grep "bash -ms mininet:sw" | grep -v color | wc -l')
             self.handle.expect("color")
             self.handle.expect("\$")
             response2 = self.handle.before
@@ -274,10 +260,10 @@
             else:
                 return main.FALSE
         else :
-            main.log.error("Connection failed to the host") 
+            main.log.error("Connection failed to the host")
 
     def start_tcpdump(self, filename, intf = "eth0", port = "port 6633", user="admin"):
-        ''' 
+        '''
         Runs tpdump on an intferface and saves the file
         intf can be specified, or the default eth0 is used
         '''
@@ -297,7 +283,7 @@
             elif i == 2:
                 main.log.error(self.name + ": tcpdump command timed out! Check interface name, given interface was: " + intf)
                 return main.FALSE
-            elif i ==3: 
+            elif i ==3:
                 main.log.info(self.name +": " +  self.handle.before)
                 return main.TRUE
             else:
@@ -336,7 +322,7 @@
 
     def run_optical_mn_script(self):
         '''
-            This function is only meant for Packet Optical. 
+            This function is only meant for Packet Optical.
             It runs the python script "optical.py" to create the packet layer(mn)
             topology
         '''
@@ -354,9 +340,9 @@
             return main.FALSE
 
     def disconnect(self):
-        '''    
-        Called at the end of the test to disconnect the handle.    
-        '''    
+        '''
+        Called at the end of the test to disconnect the handle.
+        '''
         response = ''
         #print "Disconnecting Mininet"
         if self.handle:
@@ -415,8 +401,8 @@
         Usage:
         * specify action ('add' or 'remove')
           when removing, pass in the same argument as you would add. It will
-          delete that specific rule. 
-        * specify the destination ip to block with dst_ip 
+          delete that specific rule.
+        * specify the destination ip to block with dst_ip
         * specify destination port to block to dst_port
         * optional packet type to block (default tcp)
         * optional iptables rule (default DROP)
@@ -447,8 +433,8 @@
             return
         else:
 
-            #If there is no existing rule in the iptables, we will see an 
-            #'iptables:'... message. We expect to see this message. 
+            #If there is no existing rule in the iptables, we will see an
+            #'iptables:'... message. We expect to see this message.
             #Otherwise, if there IS an existing rule, we will get the prompt
             # back, hence why we expect $ for remove type. We want to remove
             # an already existing rule
@@ -456,7 +442,7 @@
             if action_type == 'add':
                 #NOTE: "iptables:" expect is a result of return from the command
                 #      iptables -C ...
-                #      Any changes by the iptables command return string 
+                #      Any changes by the iptables command return string
                 #      will result in failure of the function. (deemed unlikely
                 #      at the time of writing this function)
                 #Check for existing rules on current input
@@ -488,7 +474,7 @@
                 match_result = main.TRUE
             else:
                 match_result = main.FALSE
-            #If match_result is main.TRUE, it means there is no matching rule. 
+            #If match_result is main.TRUE, it means there is no matching rule.
 
             #If tables does not exist and expected prompt is returned, go ahead and
             #add iptables rule
diff --git a/TestON/drivers/common/cli/onosclidriver.py b/TestON/drivers/common/cli/onosclidriver.py
index c987f70..838e6f4 100644
--- a/TestON/drivers/common/cli/onosclidriver.py
+++ b/TestON/drivers/common/cli/onosclidriver.py
@@ -18,13 +18,10 @@
 '''
 
 import sys
-import time
 import pexpect
 import re
 import traceback
-import os.path
-import pydoc
-import re
+#import os.path
 sys.path.append("../")
 from drivers.common.clidriver import CLI
 
@@ -1106,7 +1103,7 @@
 
             if i == 0:
                 main.log.error("Error in adding point-to-point intent")
-                return handle
+                return main.FALSE
             else:
                 return main.TRUE
 
@@ -2032,7 +2029,7 @@
 
             if i == 0:
                 main.log.error("Error in getting ports")
-                return (ouput, "Error")
+                return (output, "Error")
             else:
                 result = output
                 return result
@@ -2067,7 +2064,7 @@
 
             if i == 0:
                 main.log.error("Error in getting ports")
-                return (ouput, "Error")
+                return (output, "Error")
             else:
                 result = output
                 return result
@@ -2101,7 +2098,7 @@
 
             if i == 0:
                 main.log.error("Error in getting ports")
-                return (ouput, "Error")
+                return (output, "Error")
             else:
                 result = output
                 return result
diff --git a/TestON/drivers/common/cli/onosdriver.py b/TestON/drivers/common/cli/onosdriver.py
index 4bf409c..c8713e5 100644
--- a/TestON/drivers/common/cli/onosdriver.py
+++ b/TestON/drivers/common/cli/onosdriver.py
@@ -20,10 +20,8 @@
 import sys
 import time
 import pexpect
-import re
 import traceback
 import os.path
-import pydoc
 sys.path.append("../")
 from drivers.common.clidriver import CLI
 
@@ -224,12 +222,12 @@
     def git_pull(self, comp1=""):
         '''
         Assumes that "git pull" works without login
-        
+
         This function will perform a git pull on the ONOS instance.
         If used as git_pull("NODE") it will do git pull + NODE. This is
         for the purpose of pulling from other nodes if necessary.
 
-        Otherwise, this function will perform a git pull in the 
+        Otherwise, this function will perform a git pull in the
         ONOS repository. If it has any problems, it will return main.ERROR
         If it successfully does a git_pull, it will return a 1 (main.TRUE)
         If it has no updates, it will return 3.
@@ -244,14 +242,13 @@
                 self.handle.sendline("git pull")
             else:
                 self.handle.sendline("git pull " + comp1)
-           
-            uptodate = 0
+
             i=self.handle.expect(['fatal',
                 'Username\sfor\s(.*):\s',
                 '\sfile(s*) changed,\s',
                 'Already up-to-date',
                 'Aborting',
-                'You\sare\snot\scurrently\son\sa\sbranch', 
+                'You\sare\snot\scurrently\son\sa\sbranch',
                 'You\sasked\sme\sto\spull\swithout\stelling\sme\swhich\sbranch\syou',
                 'Pull\sis\snot\spossible\sbecause\syou\shave\sunmerged\sfiles',
                 pexpect.TIMEOUT],
@@ -270,7 +267,7 @@
                 return main.TRUE # So that only when git pull is done, we do mvn clean compile
             elif i==3:
                 main.log.info(self.name + ": Git Pull - Already up to date")
-                return i 
+                return i
             elif i==4:
                 main.log.info(self.name + ": Git Pull - Aborting... Are there conflicting git files?")
                 return main.ERROR
@@ -456,8 +453,6 @@
         #Create the cell file in the directory for writing (w+)
         cell_file = open(temp_directory+file_name , 'w+')
        
-        comment = ""
-        comment_string = "#"+ comment
         #Feature string is hardcoded environment variables
         #That you may wish to use by default on startup.
         #Note that you  may not want certain features listed
@@ -625,8 +620,8 @@
 
             handle_before = self.handle.before
             print "handle_before = ", self.handle.before
-            handle_after = str(self.handle.after)
-            
+            #handle_after = str(self.handle.after)
+
             #self.handle.sendline("")
             #self.handle.expect("\$")
             #handle_more = str(self.handle.before)
@@ -1079,13 +1074,13 @@
                     key, value = var.strip().split("=")
                     topology[key] = value
             #print "topology = ", topology
-            devices = topology.get('devices', False)
+            #devices = topology.get('devices', False)
             #print "devices = ", devices
-            links = topology.get('links', False)
+            #links = topology.get('links', False)
             #print "links = ", links
-            SCCs = topology.get('SCC(s)', False)
+            #SCCs = topology.get('SCC(s)', False)
             #print "SCCs = ", SCCs
-            paths = topology.get('paths', False)
+            #paths = topology.get('paths', False)
             #print "paths = ", paths
 
             return topology