diff --git a/zk/base.py b/zk/base.py
index 286f3fd..d43a3d4 100644
--- a/zk/base.py
+++ b/zk/base.py
@@ -1,6 +1,5 @@
 # -*- coding: utf-8 -*-
 import sys
-#from builtins import str
 from datetime import datetime
 from socket import AF_INET, SOCK_DGRAM, SOCK_STREAM, socket, timeout
 from struct import pack, unpack
@@ -8,10 +7,11 @@ import codecs
 
 from zk import const
 from zk.attendance import Attendance
-from zk.exception import ZKErrorResponse, ZKNetworkError
+from zk.exception import ZKErrorConnection, ZKErrorResponse, ZKNetworkError
 from zk.user import User
 from zk.finger import Finger
 
+
 def safe_cast(val, to_type, default=None):
     #https://stackoverflow.com/questions/6330071/safe-casting-in-python
     try:
@@ -21,9 +21,10 @@ def safe_cast(val, to_type, default=None):
 
 
 def make_commkey(key, session_id, ticks=50):
-    """take a password and session_id and scramble them to send to the time
-    clock.
-    copied from commpro.c - MakeKey"""
+    """
+    take a password and session_id and scramble them to send to the machine.
+    copied from commpro.c - MakeKey
+    """
     key = int(key)
     session_id = int(session_id)
     k = 0
@@ -55,16 +56,15 @@ def make_commkey(key, session_id, ticks=50):
         k[3] ^ B)
     return k
 
+
 class ZK_helper(object):
-    """ helper class """
+    """
+    helper class
+    """
     def __init__(self, ip, port=4370):
         self.address = (ip, port)
         self.ip = ip
         self.port = port
-        #self.timeout = timeout
-        #self.password = password # passint
-        #self.firmware = int(firmware) #TODO check minor version?
-        #self.tcp = tcp
 
     def test_ping(self):
         """
@@ -83,34 +83,43 @@ class ZK_helper(object):
 
     def test_tcp(self):
         self.client = socket(AF_INET, SOCK_STREAM)
-        self.client.settimeout(10) # fixed test
+        self.client.settimeout(10)
         res = self.client.connect_ex(self.address)
         self.client.close()
         return res
 
-    def test_udp(self): # WIP:
+    def test_udp(self):
         self.client = socket(AF_INET, SOCK_DGRAM)
-        self.client.settimeout(10) # fixed test
+        self.client.settimeout(10)
+
 
 class ZK(object):
-    """ Clase ZK """
+    """
+    ZK main class
+    """
     def __init__(self, ip, port=4370, timeout=60, password=0, force_udp=False, ommit_ping=False, verbose=False, encoding='UTF-8'):
-        """ initialize instance """
-        self.is_connect = False
-        self.is_enabled = True #let's asume
-        self.helper = ZK_helper(ip, port)
+        """
+        initialize instance
+        """
+        User.encoding = encoding
         self.__address = (ip, port)
         self.__sock = socket(AF_INET, SOCK_DGRAM)
         self.__sock.settimeout(timeout)
         self.__timeout = timeout
         self.__password = password # passint
-        #self.firmware = int(firmware) #dummy
+        self.__session_id = 0
+        self.__reply_id = const.USHRT_MAX - 1
+        self.__data_recv = None
+        self.__data = None
+
+        self.is_connect = False
+        self.is_enabled = True
+        self.helper = ZK_helper(ip, port)
         self.force_udp = force_udp
         self.ommit_ping = ommit_ping
         self.verbose = verbose
         self.encoding = encoding
-        User.encoding = encoding
-        self.tcp = False
+        self.tcp = not force_udp
         self.users = 0
         self.fingers = 0
         self.records = 0
@@ -128,17 +137,14 @@ class ZK(object):
         self.next_user_id='1'
         self.user_packet_size = 28 # default zk6
         self.end_live_capture = False
-        self.__session_id = 0
-        self.__reply_id = const.USHRT_MAX-1
-        self.__data_recv = None
-        self.__data = None
 
     def __nonzero__(self):
-        """ for boolean test"""
+        """
+        for boolean test
+        """
         return self.is_connect
 
     def __create_socket(self):
-        """ based on self.tcp"""
         if self.tcp:
             self.__sock = socket(AF_INET, SOCK_STREAM)
             self.__sock.settimeout(self.__timeout)
@@ -148,18 +154,17 @@ class ZK(object):
             self.__sock.settimeout(self.__timeout)
 
     def __create_tcp_top(self, packet):
-        """ witch the complete packet set top header """
+        """
+        witch the complete packet set top header
+        """
         length = len(packet)
         top = pack('<HHI', const.MACHINE_PREPARE_DATA_1, const.MACHINE_PREPARE_DATA_2, length)
         return top + packet
 
     def __create_header(self, command, command_string, session_id, reply_id):
-        '''
+        """
         Puts a the parts that make up a packet together and packs them into a byte string
-
-        MODIFIED now, without initial checksum
-        '''
-        #checksum = 0 always? for calculating
+        """
         buf = pack('<4H', command, 0, session_id, reply_id) + command_string
         buf = unpack('8B' + '%sB' % len(command_string), buf)
         checksum = unpack('H', self.__create_checksum(buf))[0]
@@ -171,10 +176,10 @@ class ZK(object):
         return buf + command_string
 
     def __create_checksum(self, p):
-        '''
+        """
         Calculates the checksum of the packet to be sent to the time clock
         Copied from zkemsdk.c
-        '''
+        """
         l = len(p)
         checksum = 0
         while l > 1:
@@ -197,18 +202,23 @@ class ZK(object):
         return pack('H', checksum)
 
     def __test_tcp_top(self, packet):
-        """ return size!"""
+        """
+        return size!
+        """
         if len(packet)<=8:
-            return 0 # invalid packet
+            return 0
         tcp_header = unpack('<HHI', packet[:8])
         if tcp_header[0] == const.MACHINE_PREPARE_DATA_1 and tcp_header[1] == const.MACHINE_PREPARE_DATA_2:
             return tcp_header[2]
-        return 0 #never everis 0!
+        return 0
 
     def __send_command(self, command, command_string=b'', response_size=8):
-        '''
+        """
         send command to the terminal
-        '''
+        """
+        if command != const.CMD_CONNECT and not self.is_connect:
+            raise ZKErrorConnection("instance are not connected.")
+
         buf = self.__create_header(command, command_string, self.__session_id, self.__reply_id)
         try:
             if self.tcp:
@@ -219,7 +229,7 @@ class ZK(object):
                 if self.__tcp_length == 0:
                     raise ZKNetworkError("TCP packet invalid")
                 self.__header = unpack('<4H', self.__tcp_data_recv[8:16])
-                self.__data_recv = self.__tcp_data_recv[8:] # dirty hack
+                self.__data_recv = self.__tcp_data_recv[8:]
             else:
                 self.__sock.sendto(buf, self.__address)
                 self.__data_recv = self.__sock.recv(response_size)
@@ -229,7 +239,7 @@ class ZK(object):
 
         self.__response = self.__header[0]
         self.__reply_id = self.__header[3]
-        self.__data = self.__data_recv[8:] #could be empty
+        self.__data = self.__data_recv[8:]
         if self.__response in [const.CMD_ACK_OK, const.CMD_PREPARE_DATA, const.CMD_DATA]:
             return {
                 'status': True,
@@ -241,7 +251,9 @@ class ZK(object):
         }
 
     def __ack_ok(self):
-        """ event ack ok """
+        """
+        event ack ok
+        """
         buf = self.__create_header(const.CMD_ACK_OK, b'', self.__session_id, const.USHRT_MAX - 1)
         try:
             if self.tcp:
@@ -253,10 +265,12 @@ class ZK(object):
             raise ZKNetworkError(str(e))
 
     def __get_data_size(self):
-        """Checks a returned packet to see if it returned CMD_PREPARE_DATA,
+        """
+        Checks a returned packet to see if it returned CMD_PREPARE_DATA,
         indicating that data packets are to be sent
 
-        Returns the amount of bytes that are going to be sent"""
+        Returns the amount of bytes that are going to be sent
+        """
         response = self.__response
         if response == const.CMD_PREPARE_DATA:
             size = unpack('I', self.__data[:4])[0]
@@ -271,14 +285,12 @@ class ZK(object):
         return data
 
     def __decode_time(self, t):
-        """Decode a timestamp retrieved from the timeclock
+        """
+        Decode a timestamp retrieved from the timeclock
 
-        copied from zkemsdk.c - DecodeTime"""
-        """
-        t = t.encode('hex')
-        t = int(self.__reverse_hex(t), 16)
-        if self.verbose: print ("decode from  %s "% format(t, '04x'))
+        copied from zkemsdk.c - DecodeTime
         """
+
         t = unpack("<I", t)[0]
         second = t % 60
         t = t // 60
@@ -300,14 +312,19 @@ class ZK(object):
         d = datetime(year, month, day, hour, minute, second)
 
         return d
+
     def __decode_timehex(self, timehex):
-        """timehex string of six bytes"""
+        """
+        timehex string of six bytes
+        """
         year, month, day, hour, minute, second = unpack("6B", timehex)
         year += 2000
         d = datetime(year, month, day, hour, minute, second)
         return d
+
     def __encode_time(self, t):
-        """Encode a timestamp so that it can be read on the timeclock
+        """
+        Encode a timestamp so that it can be read on the timeclock
         """
         # formula taken from zkemsdk.c - EncodeTime
         # can also be found in the technical manual
@@ -318,16 +335,15 @@ class ZK(object):
         return d
 
     def connect(self):
-        '''
+        """
         connect to the device
-        '''
-        self.end_live_capture = False # jic
+        """
+        self.end_live_capture = False
         if not self.ommit_ping and not self.helper.test_ping():
             raise ZKNetworkError("can't reach device (ping %s)" % self.__address[0])
-        if not self.force_udp and self.helper.test_tcp() == 0: #ok
-            self.tcp = True
+        if not self.force_udp and self.helper.test_tcp() == 0:
             self.user_packet_size = 72 # default zk8
-        self.__create_socket()# tcp based
+        self.__create_socket()
         self.__session_id = 0
         self.__reply_id = const.USHRT_MAX - 1
         cmd_response = self.__send_command(const.CMD_CONNECT)
@@ -338,7 +354,6 @@ class ZK(object):
             cmd_response = self.__send_command(const.CMD_AUTH, command_string)
         if cmd_response.get('status'):
             self.is_connect = True
-            # set the session id
             return self
         else:
             if cmd_response["code"] == const.CMD_ACK_UNAUTH:
@@ -347,33 +362,22 @@ class ZK(object):
             raise ZKErrorResponse("Invalid response: Can't connect")
 
     def disconnect(self):
-        '''
+        """
         diconnect from the connected device
-        '''
-        self.is_connect = False
+        """
         cmd_response = self.__send_command(const.CMD_EXIT)
         if cmd_response.get('status'):
+            self.is_connect = False
             if self.__sock:
-                self.__sock.close() #leave to GC
+                self.__sock.close()
             return True
         else:
             raise ZKErrorResponse("can't disconnect")
 
-    def disable_device(self):
-        '''
-        disable (lock) device, ensure no activity when process run
-        '''
-        cmd_response = self.__send_command(const.CMD_DISABLEDEVICE)
-        if cmd_response.get('status'):
-            self.is_enabled = False
-            return True
-        else:
-            raise ZKErrorResponse("Can't Disable")
-
     def enable_device(self):
-        '''
+        """
         re-enable the connected device
-        '''
+        """
         cmd_response = self.__send_command(const.CMD_ENABLEDEVICE)
         if cmd_response.get('status'):
             self.is_enabled = True
@@ -381,10 +385,21 @@ class ZK(object):
         else:
             raise ZKErrorResponse("Can't enable device")
 
+    def disable_device(self):
+        """
+        disable (lock) device, ensure no activity while some process run
+        """
+        cmd_response = self.__send_command(const.CMD_DISABLEDEVICE)
+        if cmd_response.get('status'):
+            self.is_enabled = False
+            return True
+        else:
+            raise ZKErrorResponse("Can't disable device")
+
     def get_firmware_version(self):
-        '''
+        """
         return the firmware version
-        '''
+        """
         cmd_response = self.__send_command(const.CMD_GET_VERSION,b'', 1024)
         if cmd_response.get('status'):
             firmware_version = self.__data.split(b'\x00')[0]
@@ -393,9 +408,9 @@ class ZK(object):
             raise ZKErrorResponse("Can't read frimware version")
 
     def get_serialnumber(self):
-        '''
+        """
         return the serial number
-        '''
+        """
         command = const.CMD_OPTIONS_RRQ
         command_string = b'~SerialNumber\x00'
         response_size = 1024
@@ -408,9 +423,9 @@ class ZK(object):
             raise ZKErrorResponse("Can't read serial number")
 
     def get_platform(self):
-        '''
+        """
         return the platform name
-        '''
+        """
         command = const.CMD_OPTIONS_RRQ
         command_string = b'~Platform\x00'
         response_size = 1024
@@ -421,12 +436,12 @@ class ZK(object):
             platform = platform.replace(b'=', b'')
             return platform.decode()
         else:
-            raise ZKErrorResponse("Can't get platform")
+            raise ZKErrorResponse("Can't read platform name")
 
     def get_mac(self):
-        '''
+        """
         return the mac
-        '''
+        """
         command = const.CMD_OPTIONS_RRQ
         command_string = b'MAC\x00'
         response_size = 1024
@@ -436,12 +451,12 @@ class ZK(object):
             mac = self.__data.split(b'=', 1)[-1].split(b'\x00')[0]
             return mac.decode()
         else:
-            raise ZKErrorResponse("can't get mac")
+            raise ZKErrorResponse("can't read mac address")
 
     def get_device_name(self):
-        '''
+        """
         return the device name
-        '''
+        """
         command = const.CMD_OPTIONS_RRQ
         command_string = b'~DeviceName\x00'
         response_size = 1024
@@ -451,13 +466,12 @@ class ZK(object):
             device = self.__data.split(b'=', 1)[-1].split(b'\x00')[0]
             return device.decode()
         else:
-            return "" #no name
-            #raise ZKErrorResponse("can't read device name")
+            return ""
 
     def get_face_version(self):
-        '''
+        """
         return the face version
-        '''
+        """
         command = const.CMD_OPTIONS_RRQ
         command_string = b'ZKFaceVersion\x00'
         response_size = 1024
@@ -470,9 +484,9 @@ class ZK(object):
             return None
 
     def get_fp_version(self):
-        '''
+        """
         return the fingerprint version
-        '''
+        """
         command = const.CMD_OPTIONS_RRQ
         command_string = b'~ZKFPVersion\x00'
         response_size = 1024
@@ -483,19 +497,21 @@ class ZK(object):
             response = response.replace(b'=', b'')
             return safe_cast(response, int, 0) if response else 0
         else:
-            return None
+            raise ZKErrorResponse("can't read fingerprint version")
+
     def _clear_error(self, command_string=b''):
-        """ clear ACK_error """
+        """
+        clear ACK_error
+        """
         cmd_response = self.__send_command(const.CMD_ACK_ERROR, command_string, 1024)
-        # cmd_response['code'] shuld be CMD_ACK_UNKNOWN
         cmd_response = self.__send_command(const.CMD_ACK_UNKNOWN, command_string, 1024)
         cmd_response = self.__send_command(const.CMD_ACK_UNKNOWN, command_string, 1024)
         cmd_response = self.__send_command(const.CMD_ACK_UNKNOWN, command_string, 1024)
 
     def get_extend_fmt(self):
-        '''
+        """
         determine extend fmt
-        '''
+        """
         command = const.CMD_OPTIONS_RRQ
         command_string = b'~ExtendFmt\x00'
         response_size = 1024
@@ -503,17 +519,15 @@ class ZK(object):
         cmd_response = self.__send_command(command, command_string, response_size)
         if cmd_response.get('status'):
             fmt = (self.__data.split(b'=', 1)[-1].split(b'\x00')[0])
-            #definitivo? seleccionar firmware aqui?
             return safe_cast(fmt, int, 0) if fmt else 0
         else:
             self._clear_error(command_string)
             return None
-            #raise ZKErrorResponse("Can't read extend fmt")
 
     def get_user_extend_fmt(self):
-        '''
+        """
         determine user extend fmt
-        '''
+        """
         command = const.CMD_OPTIONS_RRQ
         command_string = b'~UserExtFmt\x00'
         response_size = 1024
@@ -521,16 +535,15 @@ class ZK(object):
         cmd_response = self.__send_command(command, command_string, response_size)
         if cmd_response.get('status'):
             fmt = (self.__data.split(b'=', 1)[-1].split(b'\x00')[0])
-            #definitivo? seleccionar firmware aqui?
             return safe_cast(fmt, int, 0) if fmt else 0
         else:
             self._clear_error(command_string)
             return None
 
     def get_face_fun_on(self):
-        '''
+        """
         determine extend fmt
-        '''
+        """
         command = const.CMD_OPTIONS_RRQ
         command_string = b'FaceFunOn\x00'
         response_size = 1024
@@ -538,16 +551,15 @@ class ZK(object):
         cmd_response = self.__send_command(command, command_string, response_size)
         if cmd_response.get('status'):
             response = (self.__data.split(b'=', 1)[-1].split(b'\x00')[0])
-            #definitivo? seleccionar firmware aqui?
             return safe_cast(response, int ,0) if response else 0
         else:
             self._clear_error(command_string)
             return None
 
     def get_compat_old_firmware(self):
-        '''
+        """
         determine old firmware
-        '''
+        """
         command = const.CMD_OPTIONS_RRQ
         command_string = b'CompatOldFirmware\x00'
         response_size = 1024
@@ -555,7 +567,6 @@ class ZK(object):
         cmd_response = self.__send_command(command, command_string, response_size)
         if cmd_response.get('status'):
             response = (self.__data.split(b'=', 1)[-1].split(b'\x00')[0])
-            #definitivo? seleccionar firmware aqui?
             return safe_cast(response, int, 0) if response else 0
         else:
             self._clear_error(command_string)
@@ -577,9 +588,9 @@ class ZK(object):
         return {'ip': ip.decode(), 'mask': mask.decode(), 'gateway': gate.decode()}
 
     def get_pin_width(self):
-        '''
+        """
         return the serial number
-        '''
+        """
         command = const.CMD_GET_PINWIDTH
         command_string = b' P'
         response_size = 9
@@ -591,7 +602,9 @@ class ZK(object):
             raise ZKErrorResponse("can0t get pin width")
 
     def free_data(self):
-        """ clear buffer"""
+        """
+        clear buffer
+        """
         command = const.CMD_FREE_DATA
         cmd_response = self.__send_command(command)
         if cmd_response.get('status'):
@@ -600,7 +613,9 @@ class ZK(object):
             raise ZKErrorResponse("can't free data")
 
     def read_sizes(self):
-        """ read sizes """
+        """
+        read sizes
+        """
         command = const.CMD_GET_FREE_SIZES
         response_size = 1024
         cmd_response = self.__send_command(command,b'', response_size)
@@ -630,11 +645,11 @@ class ZK(object):
             raise ZKErrorResponse("can't read sizes")
 
     def unlock(self, time=3):
-        '''
+        """
         :param time: define time in seconds
         :return:
         thanks to https://github.com/SoftwareHouseMerida/pyzk/
-        '''
+        """
         command = const.CMD_UNLOCK
         command_string = pack("I",int(time)*10)
         cmd_response = self.__send_command(command, command_string)
@@ -644,7 +659,9 @@ class ZK(object):
             raise ZKErrorResponse("Can't open door")
 
     def __str__(self):
-        """ for debug"""
+        """
+        for debug
+        """
         return "ZK %s://%s:%s users[%i]:%i/%i fingers:%i/%i, records:%i/%i faces:%i/%i" % (
             "tcp" if self.tcp else "udp", self.__address[0], self.__address[1],
             self.user_packet_size, self.users, self.users_cap,
@@ -654,9 +671,9 @@ class ZK(object):
         )
 
     def restart(self):
-        '''
+        """
         restart the device
-        '''
+        """
         command = const.CMD_RESTART
         cmd_response = self.__send_command(command)
         if cmd_response.get('status'):
@@ -665,7 +682,9 @@ class ZK(object):
             raise ZKErrorResponse("can't restart device")
 
     def get_time(self):
-        """get Device Time"""
+        """
+        get Device Time
+        """
         command = const.CMD_GET_TIME
         response_size = 1032
         cmd_response = self.__send_command(command, b'', response_size)
@@ -675,7 +694,9 @@ class ZK(object):
             raise ZKErrorResponse("can't get time")
 
     def set_time(self, timestamp):
-        """ set Device time (pass datetime object)"""
+        """
+        set Device time (pass datetime object)
+        """
         command = const.CMD_SET_TIME
         command_string = pack(b'I', self.__encode_time(timestamp))
         cmd_response = self.__send_command(command, command_string)
@@ -685,9 +706,9 @@ class ZK(object):
             raise ZKErrorResponse("can't set time")
 
     def poweroff(self):
-        '''
+        """
         shutdown the device
-        '''
+        """
         command = const.CMD_POWEROFF
         command_string = b''
         response_size = 1032
@@ -698,9 +719,9 @@ class ZK(object):
             raise ZKErrorResponse("can't poweroff")
 
     def refresh_data(self):
-        '''
+        """
         shutdown the device
-        '''
+        """
         command = const.CMD_REFRESHDATA
         cmd_response = self.__send_command(command)
         if cmd_response.get('status'):
@@ -709,94 +730,40 @@ class ZK(object):
             raise ZKErrorResponse("can't refresh data")
 
     def test_voice(self, index=0):
-        '''
+        """
         play test voice
-         0 acceso correcto / acceso correcto
-         1 password incorrecto / clave incorrecta
-         2 la memoria del terminal está llena / acceso denegado
-         3 usuario invalido /codigo no valido
-         4 intente de nuevo  por favor / intente de nuevo por favor *
-         5 reintroduszca codigo de usuario /reintroduszca codigo
-         6 memoria del terminal llena /-
-         7 memoria de alm fich llena /-
-         8 huella duplicada / huella duplicada
-         9 acceso denegado / ya ha sido registrado
-         10 *beep* / beep kuko
-         11 el sistema vuelve al modo de verificacion / beep siren
-         12 por favor coloque su dedo  o acerque tarjeta  /-
-         13 acerca su tarjeta de nuevo  /beep bell
-         14 excedido tiempo p esta operacion  /-
-         15 coloque su dedo de nuevo  /-
-         16 coloque su dedo por ultima vez  /-
-         17 ATN numero de tarjeta está repetida  /-
-         18 proceso de registro correcto *  /-
-         19 borrado correcto /-
-         20 Numero de usuario / ponga la caja de ojos
-         21 ATN se ha llegado al max num usuarios /-
-         22 verificacion de usuarios /-
-         23 usuario no registrado /-
-         24 ATN se ha llegado al num max de registros /-
-         25 ATN la puerta no esta cerrada /-
-         26 registro de usuarios /-
-         27 borrado de usuarios /-
-         28 coloque su dedo  /-
-         29 registre la tarjeta de administrador /-
-         30 0 /-
-         31 1 /-
-         32 2 /-
-         33 3 /-
-         34 4 /-
-         35 5 /-
-         36 6 /-
-         37 7 /-
-         38 8 /-
-         39 9 /-
-         40 PFV seleccione numero de usuario /-
-         41 registrar /-
-         42 operacion correcta /-
-         43 PFV acerque su tarjeta /-
-         43 la tarjeta ha sido registrada /-
-         45 error en operacion /-
-         46 PFV acerque tarjeta de administracion, p confirmacion /-
-         47 descarga de fichajes /-
-         48 descarga de usuarios /-
-         49 carga de usuarios /-
-         50 actualizan de firmware /-
-         51 ejeuctar ficheros de configuracion /-
-         52 confirmación de clave de acceso correcta /-
-         53 error en operacion de tclado /-
-         54 borrar todos los usuarios /-
-         55 restaurar terminal con configuracion por defecto /-
-         56 introduzca numero de usuario /-
-         57 teclado bloqueado /-
-         58 error en la gestión de la tarjeta  /-
-         59 establezca una clave de acceso /-
-         60 pulse el teclado  /-
-         61 zona de accceso invalida /-
-         62 acceso combinado invĺlido /-
-         63 verificación multiusuario /-
-         64 modo de verificación inválido /-
-         65 - /-
-
-        '''
+         0 Thank You
+         1 Incorrect Password
+         2 Access Denied
+         3 Invalid ID
+         4 Please try again
+         5 Re-enter ID
+         6 The clock is full
+         7 The clock is full
+         8 Duplicate finger
+         9 Accepted. Thank you
+         10 beep kuko
+         11 beep siren
+         12 -
+         13 beep bell
+        """
         command = const.CMD_TESTVOICE
         command_string = pack("I", index)
         cmd_response = self.__send_command(command, command_string)
         if cmd_response.get('status'):
             return True
         else:
-            return False #some devices doesn't support sound
-            #raise ZKErrorResponse("can't test voice")
+            return False
 
     def set_user(self, uid=None, name='', privilege=0, password='', group_id='', user_id='', card=0):
-        '''
+        """
         create or update user by uid
-        '''
+        """
         command = const.CMD_USER_WRQ
         if uid is None:
-            uid = self.next_uid # keeps uid=0
+            uid = self.next_uid
             if not user_id:
-                user_id = self.next_user_id # else...
+                user_id = self.next_user_id
         if not user_id:
             user_id = str(uid) #ZK6 needs uid2 == uid
         #TODO: check what happens if name is missing...
@@ -828,10 +795,7 @@ class ZK(object):
 
     def save_user_template(self, user, fingers=[]):
         """ save user and template """
-        #TODO: grabado global
-        # armar paquete de huellas
         if not isinstance(user, User):
-            #try uid
             users = self.get_users()
             tusers = list(filter(lambda x: x.uid==user, users))
             if len(tusers) == 1:
@@ -846,22 +810,22 @@ class ZK(object):
             fingers = [fingers]
         fpack = b""
         table = b""
-        fnum = 0x10 # possibly flag
+        fnum = 0x10
         tstart = 0
         for finger in fingers:
             tfp = finger.repack_only()
             table += pack("<bHbI", 2, user.uid, fnum + finger.fid, tstart)
             tstart += len(tfp)
             fpack += tfp
-        if self.user_packet_size == 28: #self.firmware == 6:
+        if self.user_packet_size == 28:
             upack = user.repack29()
-        else: # 72
+        else:
             upack = user.repack73()
         head = pack("III", len(upack), len(table), len(fpack))
         packet = head + upack + table + fpack
         self._send_with_buffer(packet)
-        command = 110 # Unknown
-        command_string = pack('<IHH', 12,0,8) # ??? write? WRQ user data?
+        command = 110
+        command_string = pack('<IHH', 12,0,8)
         cmd_response = self.__send_command(command, command_string)
         if not cmd_response.get('status'):
             raise ZKErrorResponse("Can't save utemp")
@@ -870,9 +834,7 @@ class ZK(object):
     def _send_with_buffer(self, buffer):
         MAX_CHUNK = 1024
         size = len(buffer)
-        #free_Data
         self.free_data()
-        # send prepare_data
         command = const.CMD_PREPARE_DATA
         command_string = pack('I', size)
         cmd_response = self.__send_command(command, command_string)
@@ -891,7 +853,7 @@ class ZK(object):
         command = const.CMD_DATA
         cmd_response = self.__send_command(command, command_string)
         if cmd_response.get('status'):
-            return True #refres_data (1013)?
+            return True
         else:
             raise ZKErrorResponse("Can't send chunk")
 
@@ -901,12 +863,11 @@ class ZK(object):
         for tcp via user_id:
         """
         if self.tcp and user_id:
-            command = 134 # unknown?
+            command = 134
             command_string = pack('<24sB', str(user_id), temp_id)
             cmd_response = self.__send_command(command, command_string)
-            #        users = list(filter(lambda x: x.uid==uid, users))
             if cmd_response.get('status'):
-                return True #refres_data (1013)?
+                return True
             else:
                 return False # probably empty!
         if not uid:
@@ -918,27 +879,15 @@ class ZK(object):
         command = const.CMD_DELETE_USERTEMP
         command_string = pack('hb', uid, temp_id)
         cmd_response = self.__send_command(command, command_string)
-        #        users = list(filter(lambda x: x.uid==uid, users))
         if cmd_response.get('status'):
             return True #refres_data (1013)?
         else:
             return False # probably empty!
 
     def delete_user(self, uid=0, user_id=''):
-        '''
-        delete specific user by uid
-        '''
-        """if self.tcp: should work but not tested
-            if  not user_id:
-                #we need user_id (uid2)
-                users = self.get_users()
-                if len(users) == 1:
-                    user_id = users[0].user_id
-                else: #double? posibly empty
-                    return False #can't enrool
-            command = 133 #const.CMD_DELETE_USER_2
-            command_string = pack('24s',str(user_id))
-        else:"""
+        """
+        delete specific user by uid or user_id
+        """
         if not uid:
             users = self.get_users()
             users = list(filter(lambda x: x.user_id==str(user_id), users))
@@ -952,13 +901,14 @@ class ZK(object):
             raise ZKErrorResponse("Can't delete user")
         self.refresh_data()
         if uid == (self.next_uid - 1):
-            self.next_uid = uid # quick undo
+            self.next_uid = uid
 
     def get_user_template(self, uid, temp_id=0, user_id=''):
-        """ ZKFinger VX10.0
-            for tcp:
-            command = const.CMD_USERTEMP_RRQ (doesn't work always)
-            command_string = pack('hb', uid, temp_id)
+        """
+        ZKFinger VX10.0
+        for tcp:
+        command = const.CMD_USERTEMP_RRQ (doesn't work always)
+        command_string = pack('hb', uid, temp_id)
         """
         if not uid:
             users = self.get_users()
@@ -967,13 +917,13 @@ class ZK(object):
                 return False
             uid = users[0].uid
         for _retries in range(3):
-            command = 88 # comando secreto!!! GET_USER_TEMPLATE
+            command = 88 # command secret!!! GET_USER_TEMPLATE
             command_string = pack('hb', uid, temp_id)
             response_size = 1024 + 8
             cmd_response = self.__send_command(command, command_string, response_size)
             data = self.__recieve_chunk()
             if data is not None:
-                resp = data[:-1] # 01, valid byte?
+                resp = data[:-1]
                 if resp[-6:] == b'\x00\x00\x00\x00\x00\x00': # padding? bug?
                     resp = resp[:-6]
                 return Finger(uid, temp_id, 1, resp)
@@ -983,34 +933,34 @@ class ZK(object):
             return None
 
     def get_templates(self):
-        """ return array of all fingers """
-        self.read_sizes() # last update
-        if self.fingers == 0: #lazy
+        """
+        return array of all fingers
+        """
+        self.read_sizes()
+        if self.fingers == 0:
             return []
         templates = []
         templatedata, size = self.read_with_buffer(const.CMD_DB_RRQ, const.FCT_FINGERTMP)
         if size < 4:
-            if self.verbose: print("WRN: no user data") # debug
+            if self.verbose: print("WRN: no user data")
             return []
         total_size = unpack('i', templatedata[0:4])[0]
         if self.verbose: print ("get template total size {}, size {} len {}".format(total_size, size, len(templatedata)))
-        templatedata = templatedata[4:] #total size not used
-        # ZKFinger VX10.0 the only finger firmware tested
+        templatedata = templatedata[4:]
         while total_size:
-            #print ("total_size {}".format(total_size))
             size, uid, fid, valid = unpack('HHbb',templatedata[:6])
             template = unpack("%is" % (size-6), templatedata[6:size])[0]
             finger = Finger(uid, fid, valid, template)
-            if self.verbose: print(finger) # test
+            if self.verbose: print(finger)
             templates.append(finger)
             templatedata = templatedata[size:]
             total_size -= size
         return templates
 
-    def get_users(self): #ALWAYS CALL TO GET correct user_packet_size
+    def get_users(self):
         """ return all user """
-        self.read_sizes() # last update
-        if self.users == 0: #lazy
+        self.read_sizes()
+        if self.users == 0:
             self.next_uid = 1
             self.next_user_id='1'
             return []
@@ -1019,7 +969,7 @@ class ZK(object):
         userdata, size = self.read_with_buffer(const.CMD_USERTEMP_RRQ, const.FCT_USER)
         if self.verbose: print("user size {} (= {})".format(size, len(userdata)))
         if size <= 4:
-            print("WRN: missing user data")# debug
+            print("WRN: missing user data")
             return []
         total_size = unpack("I",userdata[:4])[0]
         self.user_packet_size = total_size / self.users
@@ -1032,7 +982,6 @@ class ZK(object):
                 if uid > max_uid: max_uid = uid
                 password = (password.split(b'\x00')[0]).decode(self.encoding, errors='ignore')
                 name = (name.split(b'\x00')[0]).decode(self.encoding, errors='ignore').strip()
-                #card = unpack('I', card)[0] #or hex value?
                 group_id = str(group_id)
                 user_id = str(user_id)
                 #TODO: check card value and find in ver8
@@ -1045,26 +994,19 @@ class ZK(object):
         else:
             while len(userdata) >= 72:
                 uid, privilege, password, name, card, group_id, user_id = unpack('<HB8s24sIx7sx24s', userdata.ljust(72, b'\x00')[:72])
-                #u1 = int(uid[0].encode("hex"), 16)
-                #u2 = int(uid[1].encode("hex"), 16)
-                #uid = u1 + (u2 * 256)
-                #privilege = int(privilege.encode("hex"), 16)
                 password = (password.split(b'\x00')[0]).decode(self.encoding, errors='ignore')
                 name = (name.split(b'\x00')[0]).decode(self.encoding, errors='ignore').strip()
                 group_id = (group_id.split(b'\x00')[0]).decode(self.encoding, errors='ignore').strip()
                 user_id = (user_id.split(b'\x00')[0]).decode(self.encoding, errors='ignore')
                 if uid > max_uid: max_uid = uid
-                #card = int(unpack('I', separator)[0])
                 if not name:
                     name = "NN-%s" % user_id
                 user = User(uid, name, privilege, password, group_id, user_id, card)
                 users.append(user)
                 userdata = userdata[72:]
-        #get limits!
         max_uid += 1
         self.next_uid = max_uid
         self.next_user_id = str(max_uid)
-        #re check
         while True:
             if any(u for u in users if u.user_id == self.next_user_id):
                 max_uid += 1
@@ -1074,19 +1016,18 @@ class ZK(object):
         return users
 
     def cancel_capture(self):
-        '''
+        """
         cancel capturing finger
-        '''
+        """
         command = const.CMD_CANCELCAPTURE
         cmd_response = self.__send_command(command)
         return bool(cmd_response.get('status'))
 
     def verify_user(self):
-        '''
+        """
         start verify finger mode (after capture)
-        '''
+        """
         command = const.CMD_STARTVERIFY
-        # uid = chr(uid % 256) + chr(uid >> 8)
         cmd_response = self.__send_command(command)
         if cmd_response.get('status'):
             return True
@@ -1094,7 +1035,9 @@ class ZK(object):
             raise ZKErrorResponse("Cant Verify")
 
     def reg_event(self, flags):
-        """ reg events, """
+        """
+        reg events
+        """
         command = const.CMD_REG_EVENT
         command_string = pack ("I", flags)
         cmd_response = self.__send_command(command, command_string)
@@ -1102,66 +1045,62 @@ class ZK(object):
             raise ZKErrorResponse("cant' reg events %i" % flags)
 
     def set_sdk_build_1(self):
-        """ """
         command = const.CMD_OPTIONS_WRQ
         command_string = b"SDKBuild=1"
         cmd_response = self.__send_command(command, command_string)
         if not cmd_response.get('status'):
-            return False #raise ZKErrorResponse("can't set sdk build ")
+            return False
         return True
 
     def enroll_user(self, uid=0, temp_id=0, user_id=''):
-        '''
+        """
         start enroll user
         we need user_id (uid2)
-        '''
+        """
         command = const.CMD_STARTENROLL
         done = False
         if  not user_id:
-            #we need user_id (uid2)
             users = self.get_users()
             users = list(filter(lambda x: x.uid==uid, users))
             if len(users) >= 1:
                 user_id = users[0].user_id
-            else: #double? posibly empty
-                return False #can't enroll
+            else:
+                return False
         if self.tcp:
-            command_string = pack('<24sbb',str(user_id).encode(), temp_id, 1) # el 1 es misterio
+            command_string = pack('<24sbb',str(user_id).encode(), temp_id, 1)
         else:
-            command_string = pack('<Ib', int(user_id), temp_id) #
+            command_string = pack('<Ib', int(user_id), temp_id)
         self.cancel_capture()
         cmd_response = self.__send_command(command, command_string)
         if not cmd_response.get('status'):
             raise ZKErrorResponse("Cant Enroll user #%i [%i]" %(uid, temp_id))
-        #retorna rapido toca esperar un reg event
-        self.__sock.settimeout(60)# default 1min for finger
+        self.__sock.settimeout(60)
         attempts = 3
         while attempts:
             if self.verbose: print("A:%i esperando primer regevent" % attempts)
-            data_recv = self.__sock.recv(1032) # timeout? tarda bastante...
+            data_recv = self.__sock.recv(1032)
             self.__ack_ok()
             if self.verbose: print(codecs.encode(data_recv,'hex'))
             if self.tcp:
-                if len(data_recv) > 16: #not empty
+                if len(data_recv) > 16:
                     res = unpack("H", data_recv.ljust(24,b"\x00")[16:18])[0]
                     if self.verbose: print("res %i" % res)
                     if res == 0 or res == 6 or res == 4:
-                        # 6 timeout, 4 mismatch error, 0 can't start(why?)
                         if self.verbose: print ("posible timeout  o reg Fallido")
                         break
             else:
-                if len(data_recv) > 8: #not empty
+                if len(data_recv) > 8:
                     res = unpack("H", data_recv.ljust(16,b"\x00")[8:10])[0]
                     if self.verbose: print("res %i" % res)
                     if res == 6 or res == 4:
-                        if self.verbose: print ("posible timeout  o reg Fallido")
+                        if self.verbose: print ("posible timeout")
                         break
             if self.verbose: print ("A:%i esperando 2do regevent" % attempts)
-            data_recv = self.__sock.recv(1032) # timeout? tarda bastante...
+            data_recv = self.__sock.recv(1032)
             self.__ack_ok()
             if self.verbose: print (codecs.encode(data_recv, 'hex'))
             if self.tcp:
-                if len(data_recv) > 8: #not empty
+                if len(data_recv) > 8:
                     res = unpack("H", data_recv.ljust(24,b"\x00")[16:18])[0]
                     if self.verbose: print("res %i" % res)
                     if res == 6 or res == 4:
@@ -1171,7 +1110,7 @@ class ZK(object):
                         if self.verbose: print ("ok, continue?")
                         attempts -= 1
             else:
-                if len(data_recv) > 8: #not empty
+                if len(data_recv) > 8:
                     res = unpack("H", data_recv.ljust(16,b"\x00")[8:10])[0]
                     if self.verbose: print("res %i" % res)
                     if res == 6 or res == 4:
@@ -1181,8 +1120,7 @@ class ZK(object):
                         if self.verbose: print ("ok, continue?")
                         attempts -= 1
         if attempts == 0:
-            if self.verbose: print ("esperando 3er regevent")
-            data_recv = self.__sock.recv(1032) # timeout? tarda bastante...
+            data_recv = self.__sock.recv(1032)
             self.__ack_ok()
             if self.verbose: print (codecs.encode(data_recv, 'hex'))
             if self.tcp:
@@ -1191,9 +1129,9 @@ class ZK(object):
                 res = unpack("H", data_recv.ljust(16,b"\x00")[8:10])[0]
             if self.verbose: print("res %i" % res)
             if res == 5:
-                if self.verbose: print ("huella duplicada")
+                if self.verbose: print ("finger duplicate")
             if res == 6 or res == 4:
-                if self.verbose: print ("posible timeout  o reg Fallido")
+                if self.verbose: print ("posible timeout")
             if res  == 0:
                 size = unpack("H", data_recv.ljust(16,b"\x00")[10:12])[0]
                 pos = unpack("H", data_recv.ljust(16,b"\x00")[12:14])[0]
@@ -1205,7 +1143,7 @@ class ZK(object):
         self.verify_user()
         return done
 
-    def live_capture(self, new_timeout=10):# generator!
+    def live_capture(self, new_timeout=10):
         """ try live capture of events"""
         was_enabled = self.is_enabled
         users = self.get_users()
@@ -1214,8 +1152,8 @@ class ZK(object):
         if not self.is_enabled:
             self.enable_device()
         if self.verbose: print ("start live_capture")
-        self.reg_event(const.EF_ATTLOG) #0xFFFF
-        self.__sock.settimeout(new_timeout) # default 1 minute test?
+        self.reg_event(const.EF_ATTLOG)
+        self.__sock.settimeout(new_timeout)
         self.end_live_capture = False
         while not self.end_live_capture:
             try:
@@ -1232,7 +1170,7 @@ class ZK(object):
                     data = data_recv[8:]
                 if not header[0] == const.CMD_REG_EVENT:
                     if self.verbose: print("not event! %x" % header[0])
-                    continue # or raise error?
+                    continue
                 if not len(data):
                     if self.verbose: print ("empty")
                     continue
@@ -1248,8 +1186,8 @@ class ZK(object):
                         uid = int(user_id)
                     else:
                         uid = tuser[0].uid
-                    yield Attendance(user_id, timestamp, status, punch, uid)#punch test?
-                elif len(data) == 36 or len(data) == 32: #class 2 attendance
+                    yield Attendance(user_id, timestamp, status, punch, uid)
+                elif len(data) == 36 or len(data) == 32:
                     user_id,  status, punch, timehex = unpack('<24sBB6s', data[:32])
                     user_id = (user_id.split(b'\x00')[0]).decode(errors='ignore')
                     timestamp = self.__decode_timehex(timehex)
@@ -1270,19 +1208,21 @@ class ZK(object):
                 break
         if self.verbose: print ("exit gracefully")
         self.__sock.settimeout(self.__timeout)
-        self.reg_event(0) # TODO: test
+        self.reg_event(0)
         if not was_enabled:
             self.disable_device()
 
-    def clear_data(self, clear_type=5): # FCT_USER
-        '''
+    def clear_data(self, clear_type=5):
+        """
         clear all data (include: user, attendance report, finger database )
         2 = FCT_FINGERTMP
-        '''
+        """
         command = const.CMD_CLEAR_DATA
         command_string = pack("B", clear_type)
         cmd_response = self.__send_command(command, command_string)
         if cmd_response.get('status'):
+            self.is_connect = False
+            self.next_uid = 1
             return True
         else:
             raise ZKErrorResponse("can't clear data")
@@ -1294,18 +1234,18 @@ class ZK(object):
          must return data, broken
          """
         data = []
-        tcp_length = self.__test_tcp_top(data_recv) # tcp header
+        tcp_length = self.__test_tcp_top(data_recv)
         if self.verbose: print ("tcp_length {}, size {}".format(tcp_length, size))
         if tcp_length <= 0:
             if self.verbose: print ("Incorrect tcp packet")
             return None, b""
-        if (tcp_length - 8) < size: #broken on smaller DATAs
+        if (tcp_length - 8) < size:
             if self.verbose: print ("tcp length too small... retrying")
             resp, bh = self.__recieve_tcp_data(data_recv, tcp_length - 8)
             data.append(resp)
             size -= len(resp)
             if self.verbose: print ("new tcp DATA packet to fill misssing {}".format(size))
-            data_recv = bh + self.__sock.recv(size + 16 ) #ideal limit + header
+            data_recv = bh + self.__sock.recv(size + 16 )
             if self.verbose: print ("new tcp DATA starting with {} bytes".format(len(data_recv)))
             resp, bh = self.__recieve_tcp_data(data_recv, size)
             data.append(resp)
@@ -1313,78 +1253,67 @@ class ZK(object):
             return b''.join(data), bh
         recieved = len(data_recv)
         if self.verbose: print ("recieved {}, size {}".format(recieved, size))
-        #if (tcp_length - 16) > (recieved - 16): #broken first DATA
-        #    #reparse as more data packets?
-        #    if self.verbose: print ("trying".format(recieved, size))
-        #    _data, bh = self.__recieve_tcp_data(data_recv, tcp_length-16)
-        #analize first response
         response = unpack('HHHH', data_recv[8:16])[0]
-        if recieved >= (size + 32): #complete with ACK_OK included
+        if recieved >= (size + 32):
             if response == const.CMD_DATA:
-                resp = data_recv[16 : size + 16] # no ack?
+                resp = data_recv[16 : size + 16]
                 if self.verbose: print ("resp complete len {}".format(len(resp)))
                 return resp, data_recv[size + 16:]
             else:
                 if self.verbose: print("incorrect response!!! {}".format(response))
-                return None, b"" #broken
-        else: # response DATA incomplete (or missing ACK_OK)
+                return None, b""
+        else:
             if self.verbose: print ("try DATA incomplete (actual valid {})".format(recieved-16))
-            data.append(data_recv[16 : size + 16 ]) # w/o DATA tcp and header
-            size -= recieved - 16 # w/o DATA tcp and header
+            data.append(data_recv[16 : size + 16 ])
+            size -= recieved - 16
             broken_header = b""
-            if size < 0: #broken ack header?
+            if size < 0:
                 broken_header = data_recv[size:]
-                if self.verbose: print ("broken", (broken_header).encode('hex')) #TODO python3
-            if size > 0: #need raw data to complete
+                if self.verbose: print ("broken", (broken_header).encode('hex'))
+            if size > 0:
                 data_recv = self.__recieve_raw_data(size)
-                data.append(data_recv) # w/o tcp and header
+                data.append(data_recv)
             return b''.join(data), broken_header
-            #get cmd_ack_ok on __rchunk
-
 
     def __recieve_raw_data(self, size):
         """ partial data ? """
         data = []
         if self.verbose: print ("expecting {} bytes raw data".format(size))
         while size > 0:
-            data_recv = self.__sock.recv(size) #ideal limit?
+            data_recv = self.__sock.recv(size)
             recieved = len(data_recv)
             if self.verbose: print ("partial recv {}".format(recieved))
             if recieved < 100 and self.verbose: print ("   recv {}".format(codecs.encode(data_recv, 'hex')))
-            data.append(data_recv) # w/o tcp and header
+            data.append(data_recv)
             size -= recieved
             if self.verbose: print ("still need {}".format(size))
         return b''.join(data)
 
     def __recieve_chunk(self):
         """ recieve a chunk """
-        if self.__response == const.CMD_DATA: # less than 1024!!!
-            if self.tcp: #MUST CHECK TCP SIZE
+        if self.__response == const.CMD_DATA:
+            if self.tcp:
                 if self.verbose: print ("_rc_DATA! is {} bytes, tcp length is {}".format(len(self.__data), self.__tcp_length))
                 if len(self.__data) < (self.__tcp_length - 8):
                     need = (self.__tcp_length - 8) - len(self.__data)
                     if self.verbose: print ("need more data: {}".format(need))
                     more_data = self.__recieve_raw_data(need)
                     return b''.join([self.__data, more_data])
-                else: #enough data
+                else:
                     if self.verbose: print ("Enough data")
                     return self.__data
-            else: #UDP
+            else:
                 if self.verbose: print ("_rc len is {}".format(len(self.__data)))
-                return self.__data #without headers
+                return self.__data
         elif self.__response == const.CMD_PREPARE_DATA:
             data = []
-            size = self.__get_data_size() # from prepare data response...
+            size = self.__get_data_size()
             if self.verbose: print ("recieve chunk: prepare data size is {}".format(size))
             if self.tcp:
-                if self.verbose: print ("recieve chunk: len data is {}".format(len(self.__data)))
-                #ideally 8 bytes of PREPARE_DATA only...
-                #but sometimes it comes with data...
-
-                if len(self.__data) >= (8 + size): #prepare data with actual data! should be 8+size+32
-                    data_recv = self.__data[8:] #  no need for more data! test, maybe -32
+                if len(self.__data) >= (8 + size):
+                    data_recv = self.__data[8:]
                 else:
-                    data_recv = self.__data[8:] + self.__sock.recv(size + 32) #could have two commands
+                    data_recv = self.__data[8:] + self.__sock.recv(size + 32)
                 resp, broken_header = self.__recieve_tcp_data(data_recv, size)
                 data.append(resp)
                 # get CMD_ACK_OK
@@ -1392,14 +1321,13 @@ class ZK(object):
                     data_recv = broken_header + self.__sock.recv(16)
                 else:
                     data_recv = broken_header
-                #could be broken
                 if len(data_recv) < 16:
                     print ("trying to complete broken ACK %s /16" % len(data_recv))
-                    if self.verbose: print (data_recv.encode('hex')) #todo python3
+                    if self.verbose: print (data_recv.encode('hex'))
                     data_recv += self.__sock.recv(16 - len(data_recv)) #TODO: CHECK HERE_!
                 if not self.__test_tcp_top(data_recv):
                     if self.verbose: print ("invalid chunk tcp ACK OK")
-                    return None #b''.join(data) # incomplete?
+                    return None
                 response = unpack('HHHH', data_recv[8:16])[0]
                 if response == const.CMD_ACK_OK:
                     if self.verbose: print ("chunk tcp ACK OK!")
@@ -1409,30 +1337,30 @@ class ZK(object):
                 return None
 
                 return resp
-            #else udp
-            while True: #limitado por respuesta no por tamaño
+            while True:
                 data_recv = self.__sock.recv(1024+8)
                 response = unpack('<4H', data_recv[:8])[0]
                 if self.verbose: print ("# packet response is: {}".format(response))
                 if response == const.CMD_DATA:
-                    data.append(data_recv[8:]) #header turncated
-                    size -= 1024 #UDP
+                    data.append(data_recv[8:])
+                    size -= 1024
                 elif response == const.CMD_ACK_OK:
-                    break #without problem.
+                    break
                 else:
-                    #truncado! continuar?
                     if self.verbose: print ("broken!")
                     break
                 if self.verbose: print ("still needs %s" % size)
             return b''.join(data)
         else:
             if self.verbose: print ("invalid response %s" % self.__response)
-            return None #("can't get user template")
+            return None
 
     def __read_chunk(self, start, size):
-        """ read a chunk from buffer """
+        """
+        read a chunk from buffer
+        """
         for _retries in range(3):
-            command = 1504 #CMD_READ_BUFFER
+            command = 1504
             command_string = pack('<ii', start, size)
             if self.tcp:
                 response_size = size + 32
@@ -1446,9 +1374,11 @@ class ZK(object):
             raise ZKErrorResponse("can't read chunk %i:[%i]" % (start, size))
 
     def read_with_buffer(self, command, fct=0 ,ext=0):
-        """ Test read info with buffered command (ZK6: 1503) """
+        """
+        Test read info with buffered command (ZK6: 1503)
+        """
         if self.tcp:
-            MAX_CHUNK = 0xFFc0 #arbitrary, below 0x10008
+            MAX_CHUNK = 0xFFc0
         else:
             MAX_CHUNK = 16 * 1024
         command_string = pack('<bhii', 1, command, fct, ext)
@@ -1460,23 +1390,21 @@ class ZK(object):
         if not cmd_response.get('status'):
             raise ZKErrorResponse("RWB Not supported")
         if cmd_response['code'] == const.CMD_DATA:
-            #direct!!! small!!!
-            if self.tcp: #MUST CHECK TCP SIZE
+            if self.tcp:
                 if self.verbose: print ("DATA! is {} bytes, tcp length is {}".format(len(self.__data), self.__tcp_length))
                 if len(self.__data) < (self.__tcp_length - 8):
                     need = (self.__tcp_length - 8) - len(self.__data)
                     if self.verbose: print ("need more data: {}".format(need))
                     more_data = self.__recieve_raw_data(need)
                     return b''.join([self.__data, more_data]), len(self.__data) + len(more_data)
-                else: #enough data
+                else:
                     if self.verbose: print ("Enough data")
                     size = len(self.__data)
                     return self.__data, size
-            else: #udp is direct
+            else:
                 size = len(self.__data)
                 return self.__data, size
-        #else ACK_OK with size
-        size = unpack('I', self.__data[1:5])[0]  # extra info???
+        size = unpack('I', self.__data[1:5])[0]
         if self.verbose: print ("size fill be %i" % size)
         remain = size % MAX_CHUNK
         packets = (size-remain) // MAX_CHUNK # should be size /16k
@@ -1486,42 +1414,44 @@ class ZK(object):
             start += MAX_CHUNK
         if remain:
             data.append(self.__read_chunk(start, remain))
-            start += remain # Debug
+            start += remain
         self.free_data()
         if self.verbose: print ("_read w/chunk %i bytes" % start)
         return b''.join(data), start
 
     def get_attendance(self):
-        """ return attendance record """
+        """
+        return attendance record
+        """
         self.read_sizes()
-        if self.records == 0: #lazy
+        if self.records == 0:
             return []
         users = self.get_users()
         if self.verbose: print (users)
         attendances = []
         attendance_data, size = self.read_with_buffer(const.CMD_ATTLOG_RRQ)
         if size < 4:
-            if self.verbose: print ("WRN: no attendance data") # debug
+            if self.verbose: print ("WRN: no attendance data")
             return []
         total_size = unpack("I", attendance_data[:4])[0]
         record_size = total_size/self.records
         if self.verbose: print ("record_size is ", record_size)
-        attendance_data = attendance_data[4:] #total size not used
-        if record_size == 8 : #ultra old format
-            while len(attendance_data) >= 8:#TODO RETEST ZK6!!!
+        attendance_data = attendance_data[4:]
+        if record_size == 8:
+            while len(attendance_data) >= 8:
                 uid, status, timestamp, punch = unpack('HB4sB', attendance_data.ljust(8, b'\x00')[:8])
                 if self.verbose: print (codecs.encode(attendance_data[:8], 'hex'))
                 attendance_data = attendance_data[8:]
                 tuser = list(filter(lambda x: x.uid == uid, users))
                 if not tuser:
-                    user_id = str(uid) #TODO revisar pq
+                    user_id = str(uid)
                 else:
                     user_id = tuser[0].user_id
                 timestamp = self.__decode_time(timestamp)
-                attendance = Attendance(user_id, timestamp, status, punch, uid) # punch?
+                attendance = Attendance(user_id, timestamp, status, punch, uid)
                 attendances.append(attendance)
-        elif record_size == 16: # extended
-            while len(attendance_data) >= 16: #TODO RETEST ZK6
+        elif record_size == 16:
+            while len(attendance_data) >= 16:
                 user_id, timestamp, status, punch, reserved, workcode = unpack('<I4sBB2sI', attendance_data.ljust(16, b'\x00')[:16])
                 user_id = str(user_id)
                 if self.verbose: print(codecs.encode(attendance_data[:16], 'hex'))
@@ -1530,9 +1460,9 @@ class ZK(object):
                 if not tuser:
                     if self.verbose: print("no uid {}", user_id)
                     uid = str(user_id)
-                    tuser = list(filter(lambda x: x.uid == user_id, users)) # refix
+                    tuser = list(filter(lambda x: x.uid == user_id, users))
                     if not tuser:
-                        uid = str(user_id) #TODO revisar pq
+                        uid = str(user_id)
                     else:
                         uid = tuser[0].uid
                         user_id = tuser[0].user_id
@@ -1547,21 +1477,20 @@ class ZK(object):
                 if self.verbose: print (codecs.encode(attendance_data[:40], 'hex'))
                 user_id = (user_id.split(b'\x00')[0]).decode(errors='ignore')
                 timestamp = self.__decode_time(timestamp)
-                #status = int(status.encode("hex"), 16)
 
                 attendance = Attendance(user_id, timestamp, status, punch, uid)
                 attendances.append(attendance)
                 attendance_data = attendance_data[40:]
         return attendances
 
-
     def clear_attendance(self):
-        '''
+        """
         clear all attendance record
-        '''
+        """
         command = const.CMD_CLEAR_ATTLOG
         cmd_response = self.__send_command(command)
         if cmd_response.get('status'):
             return True
         else:
-            raise ZKErrorResponse("can't clear response")
\ No newline at end of file
+            raise ZKErrorResponse("Can't clear response")
+
diff --git a/zk/exception.py b/zk/exception.py
index 223f52c..22cdb31 100644
--- a/zk/exception.py
+++ b/zk/exception.py
@@ -3,6 +3,10 @@ class ZKError(Exception):
     pass
 
 
+class ZKErrorConnection(ZKError):
+    pass
+
+
 class ZKErrorResponse(ZKError):
     pass
 
diff --git a/zk/finger.py b/zk/finger.py
index 26de3f0..8de9829 100644
--- a/zk/finger.py
+++ b/zk/finger.py
@@ -1,7 +1,10 @@
 # -*- coding: utf-8 -*-
 from struct import pack #, unpack
 import codecs
+
+
 class Finger(object):
+
     def __init__(self, uid, fid, valid, template):
         self.size = len(template) # template only
         self.uid = int(uid)
@@ -16,6 +19,7 @@ class Finger(object):
 
     def repack_only(self): #only template
         return pack("H%is" % (self.size), self.size, self.template)
+
     @staticmethod
     def json_unpack(json):
         return Finger(
@@ -24,6 +28,7 @@ class Finger(object):
             valid=json['valid'],
             template=codecs.decode(json['template'],'hex')
         )
+
     def json_pack(self): #packs for json
         return {
             "size": self.size,
@@ -44,3 +49,4 @@ class Finger(object):
 
     def dump(self):
         return "<Finger> [uid:{:>3}, fid:{}, size:{:>4} v:{} t:{}]".format(self.uid, self.fid, self.size, self.valid, codecs.encode(self.template, 'hex'))
+