From 80ec17183ef444751ad40a77ac5e5f3a84f76c69 Mon Sep 17 00:00:00 2001
From: Arturo <ahernandez@agetic.gob.bo>
Date: Tue, 18 Oct 2022 15:22:54 -0400
Subject: [PATCH 1/3] :sparkles:(issue-150) additional connect_data

---
 zk/base.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/zk/base.py b/zk/base.py
index e4aa247..078ac0e 100644
--- a/zk/base.py
+++ b/zk/base.py
@@ -356,7 +356,7 @@ def __encode_time(self, t):
         )
         return d
 
-    def connect(self):
+    def connect(self, connect_data=b''):
         """
         connect to the device
 
@@ -370,7 +370,7 @@ def connect(self):
         self.__create_socket()
         self.__session_id = 0
         self.__reply_id = const.USHRT_MAX - 1
-        cmd_response = self.__send_command(const.CMD_CONNECT)
+        cmd_response = self.__send_command(const.CMD_CONNECT, connect_data)
         self.__session_id = self.__header[2]
         if cmd_response.get('code') == const.CMD_ACK_UNAUTH:
             if self.verbose: print ("try auth")

From 1979cf5ad678df124e3ea12939d3f9b3b0ca74e7 Mon Sep 17 00:00:00 2001
From: Arturo <ahernandez@agetic.gob.bo>
Date: Tue, 18 Oct 2022 16:46:05 -0400
Subject: [PATCH 2/3] :bug:(issue-150) add recv retry

---
 zk/base.py | 958 +++++++++++++++++++++++++++++++++--------------------
 1 file changed, 596 insertions(+), 362 deletions(-)

diff --git a/zk/base.py b/zk/base.py
index 078ac0e..fbaab87 100644
--- a/zk/base.py
+++ b/zk/base.py
@@ -13,7 +13,7 @@
 
 
 def safe_cast(val, to_type, default=None):
-    #https://stackoverflow.com/questions/6330071/safe-casting-in-python
+    # https://stackoverflow.com/questions/6330071/safe-casting-in-python
     try:
         return to_type(val)
     except (ValueError, TypeError):
@@ -29,31 +29,23 @@ def make_commkey(key, session_id, ticks=50):
     session_id = int(session_id)
     k = 0
     for i in range(32):
-        if (key & (1 << i)):
-            k = (k << 1 | 1)
+        if key & (1 << i):
+            k = k << 1 | 1
         else:
             k = k << 1
     k += session_id
 
-    k = pack(b'I', k)
-    k = unpack(b'BBBB', k)
+    k = pack(b"I", k)
+    k = unpack(b"BBBB", k)
     k = pack(
-        b'BBBB',
-        k[0] ^ ord('Z'),
-        k[1] ^ ord('K'),
-        k[2] ^ ord('S'),
-        k[3] ^ ord('O'))
-    k = unpack(b'HH', k)
-    k = pack(b'HH', k[1], k[0])
-
-    B = 0xff & ticks
-    k = unpack(b'BBBB', k)
-    k = pack(
-        b'BBBB',
-        k[0] ^ B,
-        k[1] ^ B,
-        B,
-        k[3] ^ B)
+        b"BBBB", k[0] ^ ord("Z"), k[1] ^ ord("K"), k[2] ^ ord("S"), k[3] ^ ord("O")
+    )
+    k = unpack(b"HH", k)
+    k = pack(b"HH", k[1], k[0])
+
+    B = 0xFF & ticks
+    k = unpack(b"BBBB", k)
+    k = pack(b"BBBB", k[0] ^ B, k[1] ^ B, B, k[3] ^ B)
     return k
 
 
@@ -77,15 +69,18 @@ def test_ping(self):
         :return: bool
         """
         import subprocess, platform
+
         # Ping parameters as function of OS
-        ping_str = "-n 1" if  platform.system().lower()=="windows" else "-c 1 -W 5"
+        ping_str = "-n 1" if platform.system().lower() == "windows" else "-c 1 -W 5"
         args = "ping " + " " + ping_str + " " + self.ip
-        need_sh = False if  platform.system().lower()=="windows" else True
+        need_sh = False if platform.system().lower() == "windows" else True
         # Ping
-        return subprocess.call(args,
-                            stdout=subprocess.PIPE,
-                            stderr=subprocess.PIPE,
-                            shell=need_sh) == 0
+        return (
+            subprocess.call(
+                args, stdout=subprocess.PIPE, stderr=subprocess.PIPE, shell=need_sh
+            )
+            == 0
+        )
 
     def test_tcp(self):
         """
@@ -110,7 +105,18 @@ class ZK(object):
     """
     ZK main class
     """
-    def __init__(self, ip, port=4370, timeout=60, password=0, force_udp=False, ommit_ping=False, verbose=False, encoding='UTF-8'):
+
+    def __init__(
+        self,
+        ip,
+        port=4370,
+        timeout=60,
+        password=0,
+        force_udp=False,
+        ommit_ping=False,
+        verbose=False,
+        encoding="UTF-8",
+    ):
         """
         Construct a new 'ZK' object.
 
@@ -128,7 +134,7 @@ def __init__(self, ip, port=4370, timeout=60, password=0, force_udp=False, ommit
         self.__sock = socket(AF_INET, SOCK_DGRAM)
         self.__sock.settimeout(timeout)
         self.__timeout = timeout
-        self.__password = password # passint
+        self.__password = password  # passint
         self.__session_id = 0
         self.__reply_id = const.USHRT_MAX - 1
         self.__data_recv = None
@@ -156,8 +162,8 @@ def __init__(self, ip, port=4370, timeout=60, password=0, force_udp=False, ommit
         self.users_av = 0
         self.rec_av = 0
         self.next_uid = 1
-        self.next_user_id='1'
-        self.user_packet_size = 28 # default zk6
+        self.next_user_id = "1"
+        self.user_packet_size = 28  # default zk6
         self.end_live_capture = False
 
     def __nonzero__(self):
@@ -180,21 +186,23 @@ def __create_tcp_top(self, packet):
         witch the complete packet set top header
         """
         length = len(packet)
-        top = pack('<HHI', const.MACHINE_PREPARE_DATA_1, const.MACHINE_PREPARE_DATA_2, length)
+        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
         """
-        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]
+        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]
         reply_id += 1
         if reply_id >= const.USHRT_MAX:
             reply_id -= const.USHRT_MAX
 
-        buf = pack('<4H', command, checksum, session_id, reply_id)
+        buf = pack("<4H", command, checksum, session_id, reply_id)
         return buf + command_string
 
     def __create_checksum(self, p):
@@ -205,7 +213,7 @@ def __create_checksum(self, p):
         l = len(p)
         checksum = 0
         while l > 1:
-            checksum += unpack('H', pack('BB', p[0], p[1]))[0]
+            checksum += unpack("H", pack("BB", p[0], p[1]))[0]
             p = p[2:]
             if checksum > const.USHRT_MAX:
                 checksum -= const.USHRT_MAX
@@ -221,27 +229,34 @@ def __create_checksum(self, p):
         while checksum < 0:
             checksum += const.USHRT_MAX
 
-        return pack('H', checksum)
+        return pack("H", checksum)
 
     def __test_tcp_top(self, packet):
         """
         return size!
         """
-        if len(packet)<=8:
+        if len(packet) <= 8:
+            if self.verbose:
+                print("incomplete response? " + codecs.encode(packet, "hex"))
             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:
+        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
 
-    def __send_command(self, command, command_string=b'', response_size=8):
+    def __send_command(self, command, command_string=b"", response_size=8):
         """
         send command to the terminal
         """
         if command not in [const.CMD_CONNECT, const.CMD_AUTH] and not self.is_connect:
             raise ZKErrorConnection("instance are not connected.")
 
-        buf = self.__create_header(command, command_string, self.__session_id, self.__reply_id)
+        buf = self.__create_header(
+            command, command_string, self.__session_id, self.__reply_id
+        )
         try:
             if self.tcp:
                 top = self.__create_tcp_top(buf)
@@ -249,34 +264,40 @@ def __send_command(self, command, command_string=b'', response_size=8):
                 self.__tcp_data_recv = self.__sock.recv(response_size + 8)
                 self.__tcp_length = self.__test_tcp_top(self.__tcp_data_recv)
                 if self.__tcp_length == 0:
-                    raise ZKNetworkError("TCP packet invalid")
-                self.__header = unpack('<4H', self.__tcp_data_recv[8:16])
+                    # retries once! TODO: determine if only in connection packet
+                    if self.verbose:
+                        print("retry recv!")
+                    self.__tcp_data_recv = self.__sock.recv(response_size + 8)
+                    self.__tcp_length = self.__test_tcp_top(self.__tcp_data_recv)
+                    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:]
             else:
                 self.__sock.sendto(buf, self.__address)
                 self.__data_recv = self.__sock.recv(response_size)
-                self.__header = unpack('<4H', self.__data_recv[:8])
+                self.__header = unpack("<4H", self.__data_recv[:8])
         except Exception as e:
             raise ZKNetworkError(str(e))
 
         self.__response = self.__header[0]
         self.__reply_id = self.__header[3]
         self.__data = self.__data_recv[8:]
-        if self.__response in [const.CMD_ACK_OK, const.CMD_PREPARE_DATA, const.CMD_DATA]:
-            return {
-                'status': True,
-                'code': self.__response
-            }
-        return {
-            'status': False,
-            'code': self.__response
-        }
+        if self.__response in [
+            const.CMD_ACK_OK,
+            const.CMD_PREPARE_DATA,
+            const.CMD_DATA,
+        ]:
+            return {"status": True, "code": self.__response}
+        return {"status": False, "code": self.__response}
 
     def __ack_ok(self):
         """
         event ack ok
         """
-        buf = self.__create_header(const.CMD_ACK_OK, b'', self.__session_id, const.USHRT_MAX - 1)
+        buf = self.__create_header(
+            const.CMD_ACK_OK, b"", self.__session_id, const.USHRT_MAX - 1
+        )
         try:
             if self.tcp:
                 top = self.__create_tcp_top(buf)
@@ -295,15 +316,15 @@ def __get_data_size(self):
         """
         response = self.__response
         if response == const.CMD_PREPARE_DATA:
-            size = unpack('I', self.__data[:4])[0]
+            size = unpack("I", self.__data[:4])[0]
             return size
         else:
             return 0
 
     def __reverse_hex(self, hex):
-        data = ''
+        data = ""
         for i in reversed(range(len(hex) / 2)):
-            data += hex[i * 2:(i * 2) + 2]
+            data += hex[i * 2 : (i * 2) + 2]
         return data
 
     def __decode_time(self, t):
@@ -351,12 +372,14 @@ def __encode_time(self, t):
         # formula taken from zkemsdk.c - EncodeTime
         # can also be found in the technical manual
         d = (
-            ((t.year % 100) * 12 * 31 + ((t.month - 1) * 31) + t.day - 1) *
-            (24 * 60 * 60) + (t.hour * 60 + t.minute) * 60 + t.second
+            ((t.year % 100) * 12 * 31 + ((t.month - 1) * 31) + t.day - 1)
+            * (24 * 60 * 60)
+            + (t.hour * 60 + t.minute) * 60
+            + t.second
         )
         return d
 
-    def connect(self, connect_data=b''):
+    def connect(self, connect_data=b""):
         """
         connect to the device
 
@@ -366,23 +389,25 @@ def connect(self, connect_data=b''):
         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:
-            self.user_packet_size = 72 # default zk8
+            self.user_packet_size = 72  # default zk8
         self.__create_socket()
         self.__session_id = 0
         self.__reply_id = const.USHRT_MAX - 1
         cmd_response = self.__send_command(const.CMD_CONNECT, connect_data)
         self.__session_id = self.__header[2]
-        if cmd_response.get('code') == const.CMD_ACK_UNAUTH:
-            if self.verbose: print ("try auth")
+        if cmd_response.get("code") == const.CMD_ACK_UNAUTH:
+            if self.verbose:
+                print("try auth")
             command_string = make_commkey(self.__password, self.__session_id)
             cmd_response = self.__send_command(const.CMD_AUTH, command_string)
-        if cmd_response.get('status'):
+        if cmd_response.get("status"):
             self.is_connect = True
             return self
         else:
             if cmd_response["code"] == const.CMD_ACK_UNAUTH:
                 raise ZKErrorResponse("Unauthenticated")
-            if self.verbose: print ("connect err response {} ".format(cmd_response["code"]))
+            if self.verbose:
+                print("connect err response {} ".format(cmd_response["code"]))
             raise ZKErrorResponse("Invalid response: Can't connect")
 
     def disconnect(self):
@@ -392,7 +417,7 @@ def disconnect(self):
         :return: bool
         """
         cmd_response = self.__send_command(const.CMD_EXIT)
-        if cmd_response.get('status'):
+        if cmd_response.get("status"):
             self.is_connect = False
             if self.__sock:
                 self.__sock.close()
@@ -407,7 +432,7 @@ def enable_device(self):
         :return: bool
         """
         cmd_response = self.__send_command(const.CMD_ENABLEDEVICE)
-        if cmd_response.get('status'):
+        if cmd_response.get("status"):
             self.is_enabled = True
             return True
         else:
@@ -420,7 +445,7 @@ def disable_device(self):
         :return: bool
         """
         cmd_response = self.__send_command(const.CMD_DISABLEDEVICE)
-        if cmd_response.get('status'):
+        if cmd_response.get("status"):
             self.is_enabled = False
             return True
         else:
@@ -430,9 +455,9 @@ 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]
+        cmd_response = self.__send_command(const.CMD_GET_VERSION, b"", 1024)
+        if cmd_response.get("status"):
+            firmware_version = self.__data.split(b"\x00")[0]
             return firmware_version.decode()
         else:
             raise ZKErrorResponse("Can't read frimware version")
@@ -442,13 +467,13 @@ def get_serialnumber(self):
         :return: the serial number
         """
         command = const.CMD_OPTIONS_RRQ
-        command_string = b'~SerialNumber\x00'
+        command_string = b"~SerialNumber\x00"
         response_size = 1024
         cmd_response = self.__send_command(command, command_string, response_size)
-        if cmd_response.get('status'):
-            serialnumber = self.__data.split(b'=', 1)[-1].split(b'\x00')[0]
-            serialnumber = serialnumber.replace(b'=', b'')
-            return serialnumber.decode() # string?
+        if cmd_response.get("status"):
+            serialnumber = self.__data.split(b"=", 1)[-1].split(b"\x00")[0]
+            serialnumber = serialnumber.replace(b"=", b"")
+            return serialnumber.decode()  # string?
         else:
             raise ZKErrorResponse("Can't read serial number")
 
@@ -457,13 +482,13 @@ def get_platform(self):
         :return: the platform name
         """
         command = const.CMD_OPTIONS_RRQ
-        command_string = b'~Platform\x00'
+        command_string = b"~Platform\x00"
         response_size = 1024
 
         cmd_response = self.__send_command(command, command_string, response_size)
-        if cmd_response.get('status'):
-            platform = self.__data.split(b'=', 1)[-1].split(b'\x00')[0]
-            platform = platform.replace(b'=', b'')
+        if cmd_response.get("status"):
+            platform = self.__data.split(b"=", 1)[-1].split(b"\x00")[0]
+            platform = platform.replace(b"=", b"")
             return platform.decode()
         else:
             raise ZKErrorResponse("Can't read platform name")
@@ -473,12 +498,12 @@ def get_mac(self):
         :return: the machine's mac address
         """
         command = const.CMD_OPTIONS_RRQ
-        command_string = b'MAC\x00'
+        command_string = b"MAC\x00"
         response_size = 1024
 
         cmd_response = self.__send_command(command, command_string, response_size)
-        if cmd_response.get('status'):
-            mac = self.__data.split(b'=', 1)[-1].split(b'\x00')[0]
+        if cmd_response.get("status"):
+            mac = self.__data.split(b"=", 1)[-1].split(b"\x00")[0]
             return mac.decode()
         else:
             raise ZKErrorResponse("can't read mac address")
@@ -490,12 +515,12 @@ def get_device_name(self):
         :return: str
         """
         command = const.CMD_OPTIONS_RRQ
-        command_string = b'~DeviceName\x00'
+        command_string = b"~DeviceName\x00"
         response_size = 1024
 
         cmd_response = self.__send_command(command, command_string, response_size)
-        if cmd_response.get('status'):
-            device = self.__data.split(b'=', 1)[-1].split(b'\x00')[0]
+        if cmd_response.get("status"):
+            device = self.__data.split(b"=", 1)[-1].split(b"\x00")[0]
             return device.decode()
         else:
             return ""
@@ -505,13 +530,13 @@ def get_face_version(self):
         :return: the face version
         """
         command = const.CMD_OPTIONS_RRQ
-        command_string = b'ZKFaceVersion\x00'
+        command_string = b"ZKFaceVersion\x00"
         response_size = 1024
 
         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]
-            return safe_cast(response, int, 0)  if response else 0
+        if cmd_response.get("status"):
+            response = self.__data.split(b"=", 1)[-1].split(b"\x00")[0]
+            return safe_cast(response, int, 0) if response else 0
         else:
             return None
 
@@ -520,18 +545,18 @@ def get_fp_version(self):
         :return: the fingerprint version
         """
         command = const.CMD_OPTIONS_RRQ
-        command_string = b'~ZKFPVersion\x00'
+        command_string = b"~ZKFPVersion\x00"
         response_size = 1024
 
         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]
-            response = response.replace(b'=', b'')
+        if cmd_response.get("status"):
+            response = self.__data.split(b"=", 1)[-1].split(b"\x00")[0]
+            response = response.replace(b"=", b"")
             return safe_cast(response, int, 0) if response else 0
         else:
             raise ZKErrorResponse("can't read fingerprint version")
 
-    def _clear_error(self, command_string=b''):
+    def _clear_error(self, command_string=b""):
         """
         clear ACK_error
         """
@@ -545,12 +570,12 @@ def get_extend_fmt(self):
         determine extend fmt
         """
         command = const.CMD_OPTIONS_RRQ
-        command_string = b'~ExtendFmt\x00'
+        command_string = b"~ExtendFmt\x00"
         response_size = 1024
 
         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])
+        if cmd_response.get("status"):
+            fmt = self.__data.split(b"=", 1)[-1].split(b"\x00")[0]
             return safe_cast(fmt, int, 0) if fmt else 0
         else:
             self._clear_error(command_string)
@@ -561,12 +586,12 @@ def get_user_extend_fmt(self):
         determine user extend fmt
         """
         command = const.CMD_OPTIONS_RRQ
-        command_string = b'~UserExtFmt\x00'
+        command_string = b"~UserExtFmt\x00"
         response_size = 1024
 
         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])
+        if cmd_response.get("status"):
+            fmt = self.__data.split(b"=", 1)[-1].split(b"\x00")[0]
             return safe_cast(fmt, int, 0) if fmt else 0
         else:
             self._clear_error(command_string)
@@ -577,13 +602,13 @@ def get_face_fun_on(self):
         determine extend fmt
         """
         command = const.CMD_OPTIONS_RRQ
-        command_string = b'FaceFunOn\x00'
+        command_string = b"FaceFunOn\x00"
         response_size = 1024
 
         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])
-            return safe_cast(response, int ,0) if response else 0
+        if cmd_response.get("status"):
+            response = self.__data.split(b"=", 1)[-1].split(b"\x00")[0]
+            return safe_cast(response, int, 0) if response else 0
         else:
             self._clear_error(command_string)
             return None
@@ -593,12 +618,12 @@ def get_compat_old_firmware(self):
         determine old firmware
         """
         command = const.CMD_OPTIONS_RRQ
-        command_string = b'CompatOldFirmware\x00'
+        command_string = b"CompatOldFirmware\x00"
         response_size = 1024
 
         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])
+        if cmd_response.get("status"):
+            response = self.__data.split(b"=", 1)[-1].split(b"\x00")[0]
             return safe_cast(response, int, 0) if response else 0
         else:
             self._clear_error(command_string)
@@ -609,29 +634,33 @@ def get_network_params(self):
         get network params
         """
         ip = self.__address[0]
-        mask = b''
-        gate = b''
-        cmd_response = self.__send_command(const.CMD_OPTIONS_RRQ, b'IPAddress\x00', 1024)
-        if cmd_response.get('status'):
-            ip = (self.__data.split(b'=', 1)[-1].split(b'\x00')[0])
-        cmd_response = self.__send_command(const.CMD_OPTIONS_RRQ, b'NetMask\x00', 1024)
-        if cmd_response.get('status'):
-            mask = (self.__data.split(b'=', 1)[-1].split(b'\x00')[0])
-        cmd_response = self.__send_command(const.CMD_OPTIONS_RRQ, b'GATEIPAddress\x00', 1024)
-        if cmd_response.get('status'):
-            gate = (self.__data.split(b'=', 1)[-1].split(b'\x00')[0])
-        return {'ip': ip.decode(), 'mask': mask.decode(), 'gateway': gate.decode()}
+        mask = b""
+        gate = b""
+        cmd_response = self.__send_command(
+            const.CMD_OPTIONS_RRQ, b"IPAddress\x00", 1024
+        )
+        if cmd_response.get("status"):
+            ip = self.__data.split(b"=", 1)[-1].split(b"\x00")[0]
+        cmd_response = self.__send_command(const.CMD_OPTIONS_RRQ, b"NetMask\x00", 1024)
+        if cmd_response.get("status"):
+            mask = self.__data.split(b"=", 1)[-1].split(b"\x00")[0]
+        cmd_response = self.__send_command(
+            const.CMD_OPTIONS_RRQ, b"GATEIPAddress\x00", 1024
+        )
+        if cmd_response.get("status"):
+            gate = self.__data.split(b"=", 1)[-1].split(b"\x00")[0]
+        return {"ip": ip.decode(), "mask": mask.decode(), "gateway": gate.decode()}
 
     def get_pin_width(self):
         """
         :return: the PIN width
         """
         command = const.CMD_GET_PINWIDTH
-        command_string = b' P'
+        command_string = b" P"
         response_size = 9
         cmd_response = self.__send_command(command, command_string, response_size)
-        if cmd_response.get('status'):
-            width = self.__data.split(b'\x00')[0]
+        if cmd_response.get("status"):
+            width = self.__data.split(b"\x00")[0]
             return bytearray(width)[0]
         else:
             raise ZKErrorResponse("can0t get pin width")
@@ -644,7 +673,7 @@ def free_data(self):
         """
         command = const.CMD_FREE_DATA
         cmd_response = self.__send_command(command)
-        if cmd_response.get('status'):
+        if cmd_response.get("status"):
             return True
         else:
             raise ZKErrorResponse("can't free data")
@@ -655,16 +684,17 @@ def read_sizes(self):
         """
         command = const.CMD_GET_FREE_SIZES
         response_size = 1024
-        cmd_response = self.__send_command(command,b'', response_size)
-        if cmd_response.get('status'):
-            if self.verbose: print(codecs.encode(self.__data,'hex'))
+        cmd_response = self.__send_command(command, b"", response_size)
+        if cmd_response.get("status"):
+            if self.verbose:
+                print(codecs.encode(self.__data, "hex"))
             size = len(self.__data)
             if len(self.__data) >= 80:
-                fields = unpack('20i', self.__data[:80])
+                fields = unpack("20i", self.__data[:80])
                 self.users = fields[4]
                 self.fingers = fields[6]
                 self.records = fields[8]
-                self.dummy = fields[10] #???
+                self.dummy = fields[10]  # ???
                 self.cards = fields[12]
                 self.fingers_cap = fields[14]
                 self.users_cap = fields[15]
@@ -673,8 +703,10 @@ def read_sizes(self):
                 self.users_av = fields[18]
                 self.rec_av = fields[19]
                 self.__data = self.__data[80:]
-            if len(self.__data) >= 12: #face info
-                fields = unpack('3i', self.__data[:12]) #dirty hack! we need more information
+            if len(self.__data) >= 12:  # face info
+                fields = unpack(
+                    "3i", self.__data[:12]
+                )  # dirty hack! we need more information
                 self.faces = fields[0]
                 self.faces_cap = fields[2]
             return True
@@ -690,20 +722,21 @@ def unlock(self, time=3):
         :return: bool
         """
         command = const.CMD_UNLOCK
-        command_string = pack("I",int(time)*10)
+        command_string = pack("I", int(time) * 10)
         cmd_response = self.__send_command(command, command_string)
-        if cmd_response.get('status'):
+        if cmd_response.get("status"):
             return True
         else:
             raise ZKErrorResponse("Can't open door")
+
     def get_lock_state(self):
-        '''
+        """
         :return: boolean
         thanks to https://github.com/icarome/pyzk/
-        '''
+        """
         command = const.CMD_DOORSTATE_RRQ
         cmd_response = self.__send_command(command)
-        if cmd_response.get('status'):
+        if cmd_response.get("status"):
             return True
         else:
             return False
@@ -712,12 +745,22 @@ def __str__(self):
         """
         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,
-            self.fingers, self.fingers_cap,
-            self.records, self.rec_cap,
-            self.faces, self.faces_cap
+        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,
+                self.fingers,
+                self.fingers_cap,
+                self.records,
+                self.rec_cap,
+                self.faces,
+                self.faces_cap,
+            )
         )
 
     def restart(self):
@@ -728,7 +771,7 @@ def restart(self):
         """
         command = const.CMD_RESTART
         cmd_response = self.__send_command(command)
-        if cmd_response.get('status'):
+        if cmd_response.get("status"):
             self.is_connect = False
             self.next_uid = 1
             return True
@@ -742,9 +785,13 @@ def write_lcd(self, line_number, text):
         :param text: text to write
         """
         command = const.CMD_WRITE_LCD
-        command_string = pack(b'<hb', line_number, 0) + b' ' + text.encode(self.encoding, errors='ignore')
+        command_string = (
+            pack(b"<hb", line_number, 0)
+            + b" "
+            + text.encode(self.encoding, errors="ignore")
+        )
         cmd_response = self.__send_command(command, command_string)
-        if cmd_response.get('status'):
+        if cmd_response.get("status"):
             return True
         else:
             raise ZKErrorResponse("can't write lcd")
@@ -755,7 +802,7 @@ def clear_lcd(self):
         """
         command = const.CMD_CLEAR_LCD
         cmd_response = self.__send_command(command)
-        if cmd_response.get('status'):
+        if cmd_response.get("status"):
             return True
         else:
             raise ZKErrorResponse("can't clear lcd")
@@ -766,8 +813,8 @@ def get_time(self):
         """
         command = const.CMD_GET_TIME
         response_size = 1032
-        cmd_response = self.__send_command(command, b'', response_size)
-        if cmd_response.get('status'):
+        cmd_response = self.__send_command(command, b"", response_size)
+        if cmd_response.get("status"):
             return self.__decode_time(self.__data[:4])
         else:
             raise ZKErrorResponse("can't get time")
@@ -779,9 +826,9 @@ def set_time(self, timestamp):
         :param timestamp: python datetime object
         """
         command = const.CMD_SET_TIME
-        command_string = pack(b'I', self.__encode_time(timestamp))
+        command_string = pack(b"I", self.__encode_time(timestamp))
         cmd_response = self.__send_command(command, command_string)
-        if cmd_response.get('status'):
+        if cmd_response.get("status"):
             return True
         else:
             raise ZKErrorResponse("can't set time")
@@ -791,10 +838,10 @@ def poweroff(self):
         shutdown the machine
         """
         command = const.CMD_POWEROFF
-        command_string = b''
+        command_string = b""
         response_size = 1032
         cmd_response = self.__send_command(command, command_string, response_size)
-        if cmd_response.get('status'):
+        if cmd_response.get("status"):
             self.is_connect = False
             self.next_uid = 1
             return True
@@ -804,7 +851,7 @@ def poweroff(self):
     def refresh_data(self):
         command = const.CMD_REFRESHDATA
         cmd_response = self.__send_command(command)
-        if cmd_response.get('status'):
+        if cmd_response.get("status"):
             return True
         else:
             raise ZKErrorResponse("can't refresh data")
@@ -875,12 +922,21 @@ def test_voice(self, index=0):
         command = const.CMD_TESTVOICE
         command_string = pack("I", index)
         cmd_response = self.__send_command(command, command_string)
-        if cmd_response.get('status'):
+        if cmd_response.get("status"):
             return True
         else:
             return False
 
-    def set_user(self, uid=None, name='', privilege=0, password='', group_id='', user_id='', card=0):
+    def set_user(
+        self,
+        uid=None,
+        name="",
+        privilege=0,
+        password="",
+        group_id="",
+        user_id="",
+        card=0,
+    ):
         """
         create or update user by uid
 
@@ -898,32 +954,56 @@ def set_user(self, uid=None, name='', privilege=0, password='', group_id='', use
             if not user_id:
                 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...
+            user_id = str(uid)  # ZK6 needs uid2 == uid
+        # TODO: check what happens if name is missing...
         if privilege not in [const.USER_DEFAULT, const.USER_ADMIN]:
             privilege = const.USER_DEFAULT
         privilege = int(privilege)
-        if self.user_packet_size == 28: #self.firmware == 6:
+        if self.user_packet_size == 28:  # self.firmware == 6:
             if not group_id:
                 group_id = 0
             try:
-                command_string = pack('HB5s8sIxBHI', uid, privilege, password.encode(self.encoding, errors='ignore'), name.encode(self.encoding, errors='ignore'), card, int(group_id), 0, int(user_id))
+                command_string = pack(
+                    "HB5s8sIxBHI",
+                    uid,
+                    privilege,
+                    password.encode(self.encoding, errors="ignore"),
+                    name.encode(self.encoding, errors="ignore"),
+                    card,
+                    int(group_id),
+                    0,
+                    int(user_id),
+                )
             except Exception as e:
-                if self.verbose: print("s_h Error pack: %s" % e)
-                if self.verbose: print("Error pack: %s" % sys.exc_info()[0])
+                if self.verbose:
+                    print("s_h Error pack: %s" % e)
+                if self.verbose:
+                    print("Error pack: %s" % sys.exc_info()[0])
                 raise ZKErrorResponse("Can't pack user")
         else:
-            name_pad = name.encode(self.encoding, errors='ignore').ljust(24, b'\x00')[:24]
-            card_str = pack('<I', int(card))[:4]
-            command_string = pack('HB8s24s4sx7sx24s', uid, privilege, password.encode(self.encoding, errors='ignore'), name_pad, card_str, group_id.encode(), user_id.encode())
-        response_size = 1024 #TODO check response?
+            name_pad = name.encode(self.encoding, errors="ignore").ljust(24, b"\x00")[
+                :24
+            ]
+            card_str = pack("<I", int(card))[:4]
+            command_string = pack(
+                "HB8s24s4sx7sx24s",
+                uid,
+                privilege,
+                password.encode(self.encoding, errors="ignore"),
+                name_pad,
+                card_str,
+                group_id.encode(),
+                user_id.encode(),
+            )
+        response_size = 1024  # TODO check response?
         cmd_response = self.__send_command(command, command_string, response_size)
-        if self.verbose: print("Response: %s" % cmd_response)
-        if not cmd_response.get('status'):
+        if self.verbose:
+            print("Response: %s" % cmd_response)
+        if not cmd_response.get("status"):
             raise ZKErrorResponse("Can't set user")
         self.refresh_data()
         if self.next_uid == uid:
-            self.next_uid += 1 # better recalculate again
+            self.next_uid += 1  # better recalculate again
         if self.next_user_id == user_id:
             self.next_user_id = str(self.next_uid)
 
@@ -936,11 +1016,11 @@ def save_user_template(self, user, fingers=[]):
         """
         if not isinstance(user, User):
             users = self.get_users()
-            tusers = list(filter(lambda x: x.uid==user, users))
+            tusers = list(filter(lambda x: x.uid == user, users))
             if len(tusers) == 1:
                 user = tusers[0]
             else:
-                tusers = list(filter(lambda x: x.user_id==str(user), users))
+                tusers = list(filter(lambda x: x.user_id == str(user), users))
                 if len(tusers) == 1:
                     user = tusers[0]
                 else:
@@ -964,9 +1044,9 @@ def save_user_template(self, user, fingers=[]):
         packet = head + upack + table + fpack
         self._send_with_buffer(packet)
         command = 110
-        command_string = pack('<IHH', 12,0,8)
+        command_string = pack("<IHH", 12, 0, 8)
         cmd_response = self.__send_command(command, command_string)
-        if not cmd_response.get('status'):
+        if not cmd_response.get("status"):
             raise ZKErrorResponse("Can't save utemp")
         self.refresh_data()
 
@@ -975,28 +1055,28 @@ def _send_with_buffer(self, buffer):
         size = len(buffer)
         self.free_data()
         command = const.CMD_PREPARE_DATA
-        command_string = pack('I', size)
+        command_string = pack("I", size)
         cmd_response = self.__send_command(command, command_string)
-        if not cmd_response.get('status'):
+        if not cmd_response.get("status"):
             raise ZKErrorResponse("Can't prepare data")
         remain = size % MAX_CHUNK
         packets = (size - remain) // MAX_CHUNK
         start = 0
         for _wlk in range(packets):
-            self.__send_chunk(buffer[start:start+MAX_CHUNK])
+            self.__send_chunk(buffer[start : start + MAX_CHUNK])
             start += MAX_CHUNK
         if remain:
-            self.__send_chunk(buffer[start:start+remain])
+            self.__send_chunk(buffer[start : start + remain])
 
     def __send_chunk(self, command_string):
         command = const.CMD_DATA
         cmd_response = self.__send_command(command, command_string)
-        if cmd_response.get('status'):
+        if cmd_response.get("status"):
             return True
         else:
             raise ZKErrorResponse("Can't send chunk")
 
-    def delete_user_template(self, uid=0, temp_id=0, user_id=''):
+    def delete_user_template(self, uid=0, temp_id=0, user_id=""):
         """
         Delete specific template
 
@@ -1006,27 +1086,27 @@ def delete_user_template(self, uid=0, temp_id=0, user_id=''):
         """
         if self.tcp and user_id:
             command = 134
-            command_string = pack('<24sB', str(user_id), temp_id)
+            command_string = pack("<24sB", str(user_id), temp_id)
             cmd_response = self.__send_command(command, command_string)
-            if cmd_response.get('status'):
+            if cmd_response.get("status"):
                 return True
             else:
-                return False # probably empty!
+                return False  # probably empty!
         if not uid:
             users = self.get_users()
-            users = list(filter(lambda x: x.user_id==str(user_id), users))
+            users = list(filter(lambda x: x.user_id == str(user_id), users))
             if not users:
                 return False
             uid = users[0].uid
         command = const.CMD_DELETE_USERTEMP
-        command_string = pack('hb', uid, temp_id)
+        command_string = pack("hb", uid, temp_id)
         cmd_response = self.__send_command(command, command_string)
-        if cmd_response.get('status'):
-            return True #refres_data (1013)?
+        if cmd_response.get("status"):
+            return True  # refres_data (1013)?
         else:
-            return False # probably empty!
+            return False  # probably empty!
 
-    def delete_user(self, uid=0, user_id=''):
+    def delete_user(self, uid=0, user_id=""):
         """
         delete specific user by uid or user_id
 
@@ -1036,20 +1116,20 @@ def delete_user(self, uid=0, user_id=''):
         """
         if not uid:
             users = self.get_users()
-            users = list(filter(lambda x: x.user_id==str(user_id), users))
+            users = list(filter(lambda x: x.user_id == str(user_id), users))
             if not users:
                 return False
             uid = users[0].uid
         command = const.CMD_DELETE_USER
-        command_string = pack('h', uid)
+        command_string = pack("h", uid)
         cmd_response = self.__send_command(command, command_string)
-        if not cmd_response.get('status'):
+        if not cmd_response.get("status"):
             raise ZKErrorResponse("Can't delete user")
         self.refresh_data()
         if uid == (self.next_uid - 1):
             self.next_uid = uid
 
-    def get_user_template(self, uid = '', temp_id=0, user_id=''):
+    def get_user_template(self, uid="", temp_id=0, user_id=""):
         """
         :param uid: user ID that are generated from device
         :param user_id: your own user ID
@@ -1057,24 +1137,26 @@ def get_user_template(self, uid = '', temp_id=0, user_id=''):
         """
         if not uid:
             users = self.get_users()
-            users = list(filter(lambda x: x.user_id==str(user_id), users))
+            users = list(filter(lambda x: x.user_id == str(user_id), users))
             if not users:
                 return False
             uid = users[0].uid
         for _retries in range(3):
-            command = 88 # command secret!!! GET_USER_TEMPLATE
-            command_string = pack('hb', uid, temp_id)
+            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]
-                if resp[-6:] == b'\x00\x00\x00\x00\x00\x00': # padding? bug?
+                if resp[-6:] == b"\x00\x00\x00\x00\x00\x00":  # padding? bug?
                     resp = resp[:-6]
                 return Finger(uid, temp_id, 1, resp)
-            if self.verbose: print ("retry get_user_template")
+            if self.verbose:
+                print("retry get_user_template")
         else:
-            if self.verbose: print ("Can't read/find finger")
+            if self.verbose:
+                print("Can't read/find finger")
             return None
 
     def get_templates(self):
@@ -1085,18 +1167,27 @@ def get_templates(self):
         if self.fingers == 0:
             return []
         templates = []
-        templatedata, size = self.read_with_buffer(const.CMD_DB_RRQ, const.FCT_FINGERTMP)
+        templatedata, size = self.read_with_buffer(
+            const.CMD_DB_RRQ, const.FCT_FINGERTMP
+        )
         if size < 4:
-            if self.verbose: print("WRN: no user data")
+            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)))
+        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:]
         while total_size:
-            size, uid, fid, valid = unpack('HHbb',templatedata[:6])
-            template = unpack("%is" % (size-6), templatedata[6:size])[0]
+            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)
+            if self.verbose:
+                print(finger)
             templates.append(finger)
             templatedata = templatedata[size:]
             total_size -= size
@@ -1109,43 +1200,87 @@ def get_users(self):
         self.read_sizes()
         if self.users == 0:
             self.next_uid = 1
-            self.next_user_id='1'
+            self.next_user_id = "1"
             return []
         users = []
         max_uid = 0
         userdata, size = self.read_with_buffer(const.CMD_USERTEMP_RRQ, const.FCT_USER)
-        if self.verbose: print("user size {} (= {})".format(size, len(userdata)))
+        if self.verbose:
+            print("user size {} (= {})".format(size, len(userdata)))
         if size <= 4:
             print("WRN: missing user data")
             return []
-        total_size = unpack("I",userdata[:4])[0]
+        total_size = unpack("I", userdata[:4])[0]
         self.user_packet_size = total_size / self.users
         if not self.user_packet_size in [28, 72]:
-            if self.verbose: print("WRN packet size would be  %i" % self.user_packet_size)
+            if self.verbose:
+                print("WRN packet size would be  %i" % self.user_packet_size)
         userdata = userdata[4:]
         if self.user_packet_size == 28:
             while len(userdata) >= 28:
-                uid, privilege, password, name, card, group_id, timezone, user_id = unpack('<HB5s8sIxBhI',userdata.ljust(28, b'\x00')[:28])
-                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()
+                (
+                    uid,
+                    privilege,
+                    password,
+                    name,
+                    card,
+                    group_id,
+                    timezone,
+                    user_id,
+                ) = unpack("<HB5s8sIxBhI", userdata.ljust(28, b"\x00")[:28])
+                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()
+                )
                 group_id = str(group_id)
                 user_id = str(user_id)
-                #TODO: check card value and find in ver8
+                # TODO: check card value and find in ver8
                 if not name:
                     name = "NN-%s" % user_id
                 user = User(uid, name, privilege, password, group_id, user_id, card)
                 users.append(user)
-                if self.verbose: print("[6]user:",uid, privilege, password, name, card, group_id, timezone, user_id)
+                if self.verbose:
+                    print(
+                        "[6]user:",
+                        uid,
+                        privilege,
+                        password,
+                        name,
+                        card,
+                        group_id,
+                        timezone,
+                        user_id,
+                    )
                 userdata = userdata[28:]
         else:
             while len(userdata) >= 72:
-                uid, privilege, password, name, card, group_id, user_id = unpack('<HB8s24sIx7sx24s', userdata.ljust(72, b'\x00')[:72])
-                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
+                uid, privilege, password, name, card, group_id, user_id = unpack(
+                    "<HB8s24sIx7sx24s", userdata.ljust(72, b"\x00")[:72]
+                )
+                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
                 if not name:
                     name = "NN-%s" % user_id
                 user = User(uid, name, privilege, password, group_id, user_id, card)
@@ -1170,7 +1305,7 @@ def cancel_capture(self):
         """
         command = const.CMD_CANCELCAPTURE
         cmd_response = self.__send_command(command)
-        return bool(cmd_response.get('status'))
+        return bool(cmd_response.get("status"))
 
     def verify_user(self):
         """
@@ -1180,7 +1315,7 @@ def verify_user(self):
         """
         command = const.CMD_STARTVERIFY
         cmd_response = self.__send_command(command)
-        if cmd_response.get('status'):
+        if cmd_response.get("status"):
             return True
         else:
             raise ZKErrorResponse("Cant Verify")
@@ -1190,20 +1325,20 @@ def reg_event(self, flags):
         reg events
         """
         command = const.CMD_REG_EVENT
-        command_string = pack ("I", flags)
+        command_string = pack("I", flags)
         cmd_response = self.__send_command(command, command_string)
-        if not cmd_response.get('status'):
+        if not cmd_response.get("status"):
             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'):
+        if not cmd_response.get("status"):
             return False
         return True
 
-    def enroll_user(self, uid=0, temp_id=0, user_id=''):
+    def enroll_user(self, uid=0, temp_id=0, user_id=""):
         """
         start enroll user
 
@@ -1214,86 +1349,105 @@ def enroll_user(self, uid=0, temp_id=0, user_id=''):
         """
         command = const.CMD_STARTENROLL
         done = False
-        if  not user_id:
+        if not user_id:
             users = self.get_users()
-            users = list(filter(lambda x: x.uid==uid, users))
+            users = list(filter(lambda x: x.uid == uid, users))
             if len(users) >= 1:
                 user_id = users[0].user_id
             else:
                 return False
         if self.tcp:
-            command_string = pack('<24sbb',str(user_id).encode(), temp_id, 1)
+            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))
+        if not cmd_response.get("status"):
+            raise ZKErrorResponse("Cant Enroll user #%i [%i]" % (uid, temp_id))
         self.__sock.settimeout(60)
         attempts = 3
         while attempts:
-            if self.verbose: print("A:%i esperando primer regevent" % attempts)
+            if self.verbose:
+                print("A:%i esperando primer regevent" % attempts)
             data_recv = self.__sock.recv(1032)
             self.__ack_ok()
-            if self.verbose: print(codecs.encode(data_recv,'hex'))
+            if self.verbose:
+                print(codecs.encode(data_recv, "hex"))
             if self.tcp:
                 if len(data_recv) > 16:
-                    res = unpack("H", data_recv.ljust(24,b"\x00")[16:18])[0]
-                    if self.verbose: print("res %i" % res)
+                    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:
-                        if self.verbose: print ("posible timeout  o reg Fallido")
+                        if self.verbose:
+                            print("posible timeout  o reg Fallido")
                         break
             else:
                 if len(data_recv) > 8:
-                    res = unpack("H", data_recv.ljust(16,b"\x00")[8:10])[0]
-                    if self.verbose: print("res %i" % res)
+                    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")
+                        if self.verbose:
+                            print("posible timeout")
                         break
-            if self.verbose: print ("A:%i esperando 2do regevent" % attempts)
+            if self.verbose:
+                print("A:%i esperando 2do regevent" % attempts)
             data_recv = self.__sock.recv(1032)
             self.__ack_ok()
-            if self.verbose: print (codecs.encode(data_recv, 'hex'))
+            if self.verbose:
+                print(codecs.encode(data_recv, "hex"))
             if self.tcp:
                 if len(data_recv) > 8:
-                    res = unpack("H", data_recv.ljust(24,b"\x00")[16:18])[0]
-                    if self.verbose: print("res %i" % res)
+                    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:
-                        if self.verbose: print ("posible timeout  o reg Fallido")
+                        if self.verbose:
+                            print("posible timeout  o reg Fallido")
                         break
                     elif res == 0x64:
-                        if self.verbose: print ("ok, continue?")
+                        if self.verbose:
+                            print("ok, continue?")
                         attempts -= 1
             else:
                 if len(data_recv) > 8:
-                    res = unpack("H", data_recv.ljust(16,b"\x00")[8:10])[0]
-                    if self.verbose: print("res %i" % res)
+                    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  o reg Fallido")
                         break
                     elif res == 0x64:
-                        if self.verbose: print ("ok, continue?")
+                        if self.verbose:
+                            print("ok, continue?")
                         attempts -= 1
         if attempts == 0:
             data_recv = self.__sock.recv(1032)
             self.__ack_ok()
-            if self.verbose: print (codecs.encode(data_recv, 'hex'))
+            if self.verbose:
+                print(codecs.encode(data_recv, "hex"))
             if self.tcp:
-                res = unpack("H", data_recv.ljust(24,b"\x00")[16:18])[0]
+                res = unpack("H", data_recv.ljust(24, b"\x00")[16:18])[0]
             else:
-                res = unpack("H", data_recv.ljust(16,b"\x00")[8:10])[0]
-            if self.verbose: print("res %i" % res)
+                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 ("finger duplicate")
+                if self.verbose:
+                    print("finger duplicate")
             if res == 6 or res == 4:
-                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]
-                if self.verbose: print("enroll ok", size, pos)
+                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]
+                if self.verbose:
+                    print("enroll ok", size, pos)
                 done = True
         self.__sock.settimeout(self.__timeout)
-        self.reg_event(0) # TODO: test
+        self.reg_event(0)  # TODO: test
         self.cancel_capture()
         self.verify_user()
         return done
@@ -1308,46 +1462,54 @@ def live_capture(self, new_timeout=10):
         self.verify_user()
         if not self.is_enabled:
             self.enable_device()
-        if self.verbose: print ("start live_capture")
+        if self.verbose:
+            print("start live_capture")
         self.reg_event(const.EF_ATTLOG)
         self.__sock.settimeout(new_timeout)
         self.end_live_capture = False
         while not self.end_live_capture:
             try:
-                if self.verbose: print ("esperando event")
+                if self.verbose:
+                    print("esperando event")
                 data_recv = self.__sock.recv(1032)
                 self.__ack_ok()
                 if self.tcp:
-                    size = unpack('<HHI', data_recv[:8])[2]
-                    header = unpack('HHHH', data_recv[8:16])
+                    size = unpack("<HHI", data_recv[:8])[2]
+                    header = unpack("HHHH", data_recv[8:16])
                     data = data_recv[16:]
                 else:
                     size = len(data_recv)
-                    header = unpack('<4H', data_recv[:8])
+                    header = unpack("<4H", data_recv[:8])
                     data = data_recv[8:]
                 if not header[0] == const.CMD_REG_EVENT:
-                    if self.verbose: print("not event! %x" % header[0])
+                    if self.verbose:
+                        print("not event! %x" % header[0])
                     continue
                 if not len(data):
-                    if self.verbose: print ("empty")
+                    if self.verbose:
+                        print("empty")
                     continue
                 while len(data) >= 12:
                     if len(data) == 12:
-                        user_id, status, punch, timehex = unpack('<IBB6s', data)
+                        user_id, status, punch, timehex = unpack("<IBB6s", data)
                         data = data[12:]
                     elif len(data) == 32:
-                        user_id,  status, punch, timehex = unpack('<24sBB6s', data[:32])
+                        user_id, status, punch, timehex = unpack("<24sBB6s", data[:32])
                         data = data[32:]
                     elif len(data) == 36:
-                        user_id,  status, punch, timehex, _other = unpack('<24sBB6s4s', data[:36])
+                        user_id, status, punch, timehex, _other = unpack(
+                            "<24sBB6s4s", data[:36]
+                        )
                         data = data[36:]
                     elif len(data) >= 52:
-                        user_id,  status, punch, timehex, _other = unpack('<24sBB6s20s', data[:52])
+                        user_id, status, punch, timehex, _other = unpack(
+                            "<24sBB6s20s", data[:52]
+                        )
                         data = data[52:]
                     if isinstance(user_id, int):
                         user_id = str(user_id)
                     else:
-                        user_id = (user_id.split(b'\x00')[0]).decode(errors='ignore')
+                        user_id = (user_id.split(b"\x00")[0]).decode(errors="ignore")
                     timestamp = self.__decode_timehex(timehex)
                     tuser = list(filter(lambda x: x.user_id == user_id, users))
                     if not tuser:
@@ -1356,12 +1518,15 @@ def live_capture(self, new_timeout=10):
                         uid = tuser[0].uid
                     yield Attendance(user_id, timestamp, status, punch, uid)
             except timeout:
-                if self.verbose: print ("time out")
-                yield None # return to keep watching
+                if self.verbose:
+                    print("time out")
+                yield None  # return to keep watching
             except (KeyboardInterrupt, SystemExit):
-                if self.verbose: print ("break")
+                if self.verbose:
+                    print("break")
                 break
-        if self.verbose: print ("exit gracefully")
+        if self.verbose:
+            print("exit gracefully")
         self.__sock.settimeout(self.__timeout)
         self.reg_event(0)
         if not was_enabled:
@@ -1374,96 +1539,124 @@ def clear_data(self):
         :return: bool
         """
         command = const.CMD_CLEAR_DATA
-        command_string = b''
+        command_string = b""
         cmd_response = self.__send_command(command, command_string)
-        if cmd_response.get('status'):
+        if cmd_response.get("status"):
             self.next_uid = 1
             return True
         else:
             raise ZKErrorResponse("can't clear data")
 
     def __recieve_tcp_data(self, data_recv, size):
-        """ data_recv, raw tcp packet
-         must analyze tcp_length
+        """data_recv, raw tcp packet
+        must analyze tcp_length
 
-         must return data, broken
-         """
+        must return data, broken
+        """
         data = []
         tcp_length = self.__test_tcp_top(data_recv)
-        if self.verbose: print ("tcp_length {}, size {}".format(tcp_length, size))
+        if self.verbose:
+            print("tcp_length {}, size {}".format(tcp_length, size))
         if tcp_length <= 0:
-            if self.verbose: print ("Incorrect tcp packet")
+            if self.verbose:
+                print("Incorrect tcp packet")
             return None, b""
         if (tcp_length - 8) < size:
-            if self.verbose: print ("tcp length too small... retrying")
+            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 )
-            if self.verbose: print ("new tcp DATA starting with {} bytes".format(len(data_recv)))
+            if self.verbose:
+                print("new tcp DATA packet to fill misssing {}".format(size))
+            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)
-            if self.verbose: print ("for misssing {} recieved {} with extra {}".format(size, len(resp), len(bh)))
-            return b''.join(data), bh
+            if self.verbose:
+                print(
+                    "for misssing {} recieved {} with extra {}".format(
+                        size, len(resp), len(bh)
+                    )
+                )
+            return b"".join(data), bh
         recieved = len(data_recv)
-        if self.verbose: print ("recieved {}, size {}".format(recieved, size))
-        response = unpack('HHHH', data_recv[8:16])[0]
+        if self.verbose:
+            print("recieved {}, size {}".format(recieved, size))
+        response = unpack("HHHH", data_recv[8:16])[0]
         if recieved >= (size + 32):
             if response == const.CMD_DATA:
                 resp = data_recv[16 : size + 16]
-                if self.verbose: print ("resp complete len {}".format(len(resp)))
-                return resp, data_recv[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))
+                if self.verbose:
+                    print("incorrect response!!! {}".format(response))
                 return None, b""
         else:
-            if self.verbose: print ("try DATA incomplete (actual valid {})".format(recieved-16))
-            data.append(data_recv[16 : size + 16 ])
+            if self.verbose:
+                print("try DATA incomplete (actual valid {})".format(recieved - 16))
+            data.append(data_recv[16 : size + 16])
             size -= recieved - 16
             broken_header = b""
             if size < 0:
                 broken_header = data_recv[size:]
-                if self.verbose: print ("broken", (broken_header).encode('hex'))
+                if self.verbose:
+                    print("broken", (broken_header).encode("hex"))
             if size > 0:
                 data_recv = self.__recieve_raw_data(size)
                 data.append(data_recv)
-            return b''.join(data), broken_header
+            return b"".join(data), broken_header
 
     def __recieve_raw_data(self, size):
-        """ partial data ? """
+        """partial data ?"""
         data = []
-        if self.verbose: print ("expecting {} bytes raw data".format(size))
+        if self.verbose:
+            print("expecting {} bytes raw data".format(size))
         while size > 0:
             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')))
+            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)
             size -= recieved
-            if self.verbose: print ("still need {}".format(size))
-        return b''.join(data)
+            if self.verbose:
+                print("still need {}".format(size))
+        return b"".join(data)
 
     def __recieve_chunk(self):
-        """ recieve a chunk """
+        """recieve a chunk"""
         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 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))
+                    if self.verbose:
+                        print("need more data: {}".format(need))
                     more_data = self.__recieve_raw_data(need)
-                    return b''.join([self.__data, more_data])
+                    return b"".join([self.__data, more_data])
                 else:
-                    if self.verbose: print ("Enough data")
+                    if self.verbose:
+                        print("Enough data")
                     return self.__data
             else:
-                if self.verbose: print ("_rc len is {}".format(len(self.__data)))
+                if self.verbose:
+                    print("_rc len is {}".format(len(self.__data)))
                 return self.__data
         elif self.__response == const.CMD_PREPARE_DATA:
             data = []
             size = self.__get_data_size()
-            if self.verbose: print ("recieve chunk: prepare data size is {}".format(size))
+            if self.verbose:
+                print("recieve chunk: prepare data size is {}".format(size))
             if self.tcp:
                 if len(self.__data) >= (8 + size):
                     data_recv = self.__data[8:]
@@ -1477,37 +1670,48 @@ def __recieve_chunk(self):
                 else:
                     data_recv = broken_header
                 if len(data_recv) < 16:
-                    print ("trying to complete broken ACK %s /16" % len(data_recv))
-                    if self.verbose: print (data_recv.encode('hex'))
-                    data_recv += self.__sock.recv(16 - len(data_recv)) #TODO: CHECK HERE_!
+                    print("trying to complete broken ACK %s /16" % len(data_recv))
+                    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")
+                    if self.verbose:
+                        print("invalid chunk tcp ACK OK")
                     return None
-                response = unpack('HHHH', data_recv[8:16])[0]
+                response = unpack("HHHH", data_recv[8:16])[0]
                 if response == const.CMD_ACK_OK:
-                    if self.verbose: print ("chunk tcp ACK OK!")
-                    return b''.join(data)
-                if self.verbose: print("bad response %s" % data_recv)
-                if self.verbose: print (codecs.encode(data,'hex'))
+                    if self.verbose:
+                        print("chunk tcp ACK OK!")
+                    return b"".join(data)
+                if self.verbose:
+                    print("bad response %s" % data_recv)
+                if self.verbose:
+                    print(codecs.encode(data, "hex"))
                 return None
 
                 return resp
             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))
+                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:])
                     size -= 1024
                 elif response == const.CMD_ACK_OK:
                     break
                 else:
-                    if self.verbose: print ("broken!")
+                    if self.verbose:
+                        print("broken!")
                     break
-                if self.verbose: print ("still needs %s" % size)
-            return b''.join(data)
+                if self.verbose:
+                    print("still needs %s" % size)
+            return b"".join(data)
         else:
-            if self.verbose: print ("invalid response %s" % self.__response)
+            if self.verbose:
+                print("invalid response %s" % self.__response)
             return None
 
     def __read_chunk(self, start, size):
@@ -1516,7 +1720,7 @@ def __read_chunk(self, start, size):
         """
         for _retries in range(3):
             command = 1504
-            command_string = pack('<ii', start, size)
+            command_string = pack("<ii", start, size)
             if self.tcp:
                 response_size = size + 32
             else:
@@ -1528,51 +1732,68 @@ def __read_chunk(self, start, size):
         else:
             raise ZKErrorResponse("can't read chunk %i:[%i]" % (start, size))
 
-    def read_with_buffer(self, command, fct=0 ,ext=0):
+    def read_with_buffer(self, command, fct=0, ext=0):
         """
         Test read info with buffered command (ZK6: 1503)
         """
         if self.tcp:
-            MAX_CHUNK = 0xFFc0
+            MAX_CHUNK = 0xFFC0
         else:
             MAX_CHUNK = 16 * 1024
-        command_string = pack('<bhii', 1, command, fct, ext)
-        if self.verbose: print ("rwb cs", command_string)
+        command_string = pack("<bhii", 1, command, fct, ext)
+        if self.verbose:
+            print("rwb cs", command_string)
         response_size = 1024
         data = []
         start = 0
         cmd_response = self.__send_command(1503, command_string, response_size)
-        if not cmd_response.get('status'):
+        if not cmd_response.get("status"):
             raise ZKErrorResponse("RWB Not supported")
-        if cmd_response['code'] == const.CMD_DATA:
+        if cmd_response["code"] == const.CMD_DATA:
             if self.tcp:
-                if self.verbose: print ("DATA! is {} bytes, tcp length is {}".format(len(self.__data), self.__tcp_length))
+                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))
+                    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)
+                    return b"".join([self.__data, more_data]), len(self.__data) + len(
+                        more_data
+                    )
                 else:
-                    if self.verbose: print ("Enough data")
+                    if self.verbose:
+                        print("Enough data")
                     size = len(self.__data)
                     return self.__data, size
             else:
                 size = len(self.__data)
                 return self.__data, size
-        size = unpack('I', self.__data[1:5])[0]
-        if self.verbose: print ("size fill be %i" % size)
+        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
-        if self.verbose: print ("rwb: #{} packets of max {} bytes, and extra {} bytes remain".format(packets, MAX_CHUNK, remain))
+        packets = (size - remain) // MAX_CHUNK  # should be size /16k
+        if self.verbose:
+            print(
+                "rwb: #{} packets of max {} bytes, and extra {} bytes remain".format(
+                    packets, MAX_CHUNK, remain
+                )
+            )
         for _wlk in range(packets):
-            data.append(self.__read_chunk(start,MAX_CHUNK))
+            data.append(self.__read_chunk(start, MAX_CHUNK))
             start += MAX_CHUNK
         if remain:
             data.append(self.__read_chunk(start, remain))
             start += remain
         self.free_data()
-        if self.verbose: print ("_read w/chunk %i bytes" % start)
-        return b''.join(data), start
+        if self.verbose:
+            print("_read w/chunk %i bytes" % start)
+        return b"".join(data), start
 
     def get_attendance(self):
         """
@@ -1584,20 +1805,26 @@ def get_attendance(self):
         if self.records == 0:
             return []
         users = self.get_users()
-        if self.verbose: print (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")
+            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)
+        record_size = total_size / self.records
+        if self.verbose:
+            print("record_size is ", record_size)
         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'))
+                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:
@@ -1609,13 +1836,17 @@ def get_attendance(self):
                 attendances.append(attendance)
         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, 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'))
+                if self.verbose:
+                    print(codecs.encode(attendance_data[:16], "hex"))
                 attendance_data = attendance_data[16:]
                 tuser = list(filter(lambda x: x.user_id == user_id, users))
                 if not tuser:
-                    if self.verbose: print("no uid {}", user_id)
+                    if self.verbose:
+                        print("no uid {}", user_id)
                     uid = str(user_id)
                     tuser = list(filter(lambda x: x.uid == user_id, users))
                     if not tuser:
@@ -1630,9 +1861,12 @@ def get_attendance(self):
                 attendances.append(attendance)
         else:
             while len(attendance_data) >= 40:
-                uid, user_id, status, timestamp, punch, space = unpack('<H24sB4sB8s', attendance_data.ljust(40, b'\x00')[:40])
-                if self.verbose: print (codecs.encode(attendance_data[:40], 'hex'))
-                user_id = (user_id.split(b'\x00')[0]).decode(errors='ignore')
+                uid, user_id, status, timestamp, punch, space = unpack(
+                    "<H24sB4sB8s", attendance_data.ljust(40, b"\x00")[:40]
+                )
+                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)
 
                 attendance = Attendance(user_id, timestamp, status, punch, uid)
@@ -1648,7 +1882,7 @@ def clear_attendance(self):
         """
         command = const.CMD_CLEAR_ATTLOG
         cmd_response = self.__send_command(command)
-        if cmd_response.get('status'):
+        if cmd_response.get("status"):
             return True
         else:
             raise ZKErrorResponse("Can't clear response")

From b816b8ba847d9bbc3beec039041dec83c460203e Mon Sep 17 00:00:00 2001
From: Arturo <ahernandez@agetic.gob.bo>
Date: Tue, 18 Oct 2022 16:47:09 -0400
Subject: [PATCH 3/3] :bug:(issue-150) keep style

---
 zk/base.py | 956 ++++++++++++++++++++---------------------------------
 1 file changed, 364 insertions(+), 592 deletions(-)

diff --git a/zk/base.py b/zk/base.py
index fbaab87..af7dcc2 100644
--- a/zk/base.py
+++ b/zk/base.py
@@ -13,7 +13,7 @@
 
 
 def safe_cast(val, to_type, default=None):
-    # https://stackoverflow.com/questions/6330071/safe-casting-in-python
+    #https://stackoverflow.com/questions/6330071/safe-casting-in-python
     try:
         return to_type(val)
     except (ValueError, TypeError):
@@ -29,23 +29,31 @@ def make_commkey(key, session_id, ticks=50):
     session_id = int(session_id)
     k = 0
     for i in range(32):
-        if key & (1 << i):
-            k = k << 1 | 1
+        if (key & (1 << i)):
+            k = (k << 1 | 1)
         else:
             k = k << 1
     k += session_id
 
-    k = pack(b"I", k)
-    k = unpack(b"BBBB", k)
+    k = pack(b'I', k)
+    k = unpack(b'BBBB', k)
     k = pack(
-        b"BBBB", k[0] ^ ord("Z"), k[1] ^ ord("K"), k[2] ^ ord("S"), k[3] ^ ord("O")
-    )
-    k = unpack(b"HH", k)
-    k = pack(b"HH", k[1], k[0])
-
-    B = 0xFF & ticks
-    k = unpack(b"BBBB", k)
-    k = pack(b"BBBB", k[0] ^ B, k[1] ^ B, B, k[3] ^ B)
+        b'BBBB',
+        k[0] ^ ord('Z'),
+        k[1] ^ ord('K'),
+        k[2] ^ ord('S'),
+        k[3] ^ ord('O'))
+    k = unpack(b'HH', k)
+    k = pack(b'HH', k[1], k[0])
+
+    B = 0xff & ticks
+    k = unpack(b'BBBB', k)
+    k = pack(
+        b'BBBB',
+        k[0] ^ B,
+        k[1] ^ B,
+        B,
+        k[3] ^ B)
     return k
 
 
@@ -69,18 +77,15 @@ def test_ping(self):
         :return: bool
         """
         import subprocess, platform
-
         # Ping parameters as function of OS
-        ping_str = "-n 1" if platform.system().lower() == "windows" else "-c 1 -W 5"
+        ping_str = "-n 1" if  platform.system().lower()=="windows" else "-c 1 -W 5"
         args = "ping " + " " + ping_str + " " + self.ip
-        need_sh = False if platform.system().lower() == "windows" else True
+        need_sh = False if  platform.system().lower()=="windows" else True
         # Ping
-        return (
-            subprocess.call(
-                args, stdout=subprocess.PIPE, stderr=subprocess.PIPE, shell=need_sh
-            )
-            == 0
-        )
+        return subprocess.call(args,
+                            stdout=subprocess.PIPE,
+                            stderr=subprocess.PIPE,
+                            shell=need_sh) == 0
 
     def test_tcp(self):
         """
@@ -105,18 +110,7 @@ class ZK(object):
     """
     ZK main class
     """
-
-    def __init__(
-        self,
-        ip,
-        port=4370,
-        timeout=60,
-        password=0,
-        force_udp=False,
-        ommit_ping=False,
-        verbose=False,
-        encoding="UTF-8",
-    ):
+    def __init__(self, ip, port=4370, timeout=60, password=0, force_udp=False, ommit_ping=False, verbose=False, encoding='UTF-8'):
         """
         Construct a new 'ZK' object.
 
@@ -134,7 +128,7 @@ def __init__(
         self.__sock = socket(AF_INET, SOCK_DGRAM)
         self.__sock.settimeout(timeout)
         self.__timeout = timeout
-        self.__password = password  # passint
+        self.__password = password # passint
         self.__session_id = 0
         self.__reply_id = const.USHRT_MAX - 1
         self.__data_recv = None
@@ -162,8 +156,8 @@ def __init__(
         self.users_av = 0
         self.rec_av = 0
         self.next_uid = 1
-        self.next_user_id = "1"
-        self.user_packet_size = 28  # default zk6
+        self.next_user_id='1'
+        self.user_packet_size = 28 # default zk6
         self.end_live_capture = False
 
     def __nonzero__(self):
@@ -186,23 +180,21 @@ def __create_tcp_top(self, packet):
         witch the complete packet set top header
         """
         length = len(packet)
-        top = pack(
-            "<HHI", const.MACHINE_PREPARE_DATA_1, const.MACHINE_PREPARE_DATA_2, length
-        )
+        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
         """
-        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]
+        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]
         reply_id += 1
         if reply_id >= const.USHRT_MAX:
             reply_id -= const.USHRT_MAX
 
-        buf = pack("<4H", command, checksum, session_id, reply_id)
+        buf = pack('<4H', command, checksum, session_id, reply_id)
         return buf + command_string
 
     def __create_checksum(self, p):
@@ -213,7 +205,7 @@ def __create_checksum(self, p):
         l = len(p)
         checksum = 0
         while l > 1:
-            checksum += unpack("H", pack("BB", p[0], p[1]))[0]
+            checksum += unpack('H', pack('BB', p[0], p[1]))[0]
             p = p[2:]
             if checksum > const.USHRT_MAX:
                 checksum -= const.USHRT_MAX
@@ -229,34 +221,28 @@ def __create_checksum(self, p):
         while checksum < 0:
             checksum += const.USHRT_MAX
 
-        return pack("H", checksum)
+        return pack('H', checksum)
 
     def __test_tcp_top(self, packet):
         """
         return size!
         """
-        if len(packet) <= 8:
-            if self.verbose:
-                print("incomplete response? " + codecs.encode(packet, "hex"))
+        if len(packet)<=8:
+            if self.verbose: print('incomplete response? ' + codecs.encode(packet,'hex'))
             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
-        ):
+        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
 
-    def __send_command(self, command, command_string=b"", response_size=8):
+    def __send_command(self, command, command_string=b'', response_size=8):
         """
         send command to the terminal
         """
         if command not in [const.CMD_CONNECT, const.CMD_AUTH] and not self.is_connect:
             raise ZKErrorConnection("instance are not connected.")
 
-        buf = self.__create_header(
-            command, command_string, self.__session_id, self.__reply_id
-        )
+        buf = self.__create_header(command, command_string, self.__session_id, self.__reply_id)
         try:
             if self.tcp:
                 top = self.__create_tcp_top(buf)
@@ -264,40 +250,39 @@ def __send_command(self, command, command_string=b"", response_size=8):
                 self.__tcp_data_recv = self.__sock.recv(response_size + 8)
                 self.__tcp_length = self.__test_tcp_top(self.__tcp_data_recv)
                 if self.__tcp_length == 0:
-                    # retries once! TODO: determine if only in connection packet
-                    if self.verbose:
-                        print("retry recv!")
+                    #retries once! TODO: determine if only in connection packet
+                    if self.verbose: print('retry recv!')
                     self.__tcp_data_recv = self.__sock.recv(response_size + 8)
                     self.__tcp_length = self.__test_tcp_top(self.__tcp_data_recv)
                     if self.__tcp_length == 0:
                         raise ZKNetworkError("TCP packet invalid")
-                self.__header = unpack("<4H", self.__tcp_data_recv[8:16])
+                self.__header = unpack('<4H', self.__tcp_data_recv[8:16])
                 self.__data_recv = self.__tcp_data_recv[8:]
             else:
                 self.__sock.sendto(buf, self.__address)
                 self.__data_recv = self.__sock.recv(response_size)
-                self.__header = unpack("<4H", self.__data_recv[:8])
+                self.__header = unpack('<4H', self.__data_recv[:8])
         except Exception as e:
             raise ZKNetworkError(str(e))
 
         self.__response = self.__header[0]
         self.__reply_id = self.__header[3]
         self.__data = self.__data_recv[8:]
-        if self.__response in [
-            const.CMD_ACK_OK,
-            const.CMD_PREPARE_DATA,
-            const.CMD_DATA,
-        ]:
-            return {"status": True, "code": self.__response}
-        return {"status": False, "code": self.__response}
+        if self.__response in [const.CMD_ACK_OK, const.CMD_PREPARE_DATA, const.CMD_DATA]:
+            return {
+                'status': True,
+                'code': self.__response
+            }
+        return {
+            'status': False,
+            'code': self.__response
+        }
 
     def __ack_ok(self):
         """
         event ack ok
         """
-        buf = self.__create_header(
-            const.CMD_ACK_OK, b"", self.__session_id, const.USHRT_MAX - 1
-        )
+        buf = self.__create_header(const.CMD_ACK_OK, b'', self.__session_id, const.USHRT_MAX - 1)
         try:
             if self.tcp:
                 top = self.__create_tcp_top(buf)
@@ -316,15 +301,15 @@ def __get_data_size(self):
         """
         response = self.__response
         if response == const.CMD_PREPARE_DATA:
-            size = unpack("I", self.__data[:4])[0]
+            size = unpack('I', self.__data[:4])[0]
             return size
         else:
             return 0
 
     def __reverse_hex(self, hex):
-        data = ""
+        data = ''
         for i in reversed(range(len(hex) / 2)):
-            data += hex[i * 2 : (i * 2) + 2]
+            data += hex[i * 2:(i * 2) + 2]
         return data
 
     def __decode_time(self, t):
@@ -372,14 +357,12 @@ def __encode_time(self, t):
         # formula taken from zkemsdk.c - EncodeTime
         # can also be found in the technical manual
         d = (
-            ((t.year % 100) * 12 * 31 + ((t.month - 1) * 31) + t.day - 1)
-            * (24 * 60 * 60)
-            + (t.hour * 60 + t.minute) * 60
-            + t.second
+            ((t.year % 100) * 12 * 31 + ((t.month - 1) * 31) + t.day - 1) *
+            (24 * 60 * 60) + (t.hour * 60 + t.minute) * 60 + t.second
         )
         return d
 
-    def connect(self, connect_data=b""):
+    def connect(self, connect_data=b''):
         """
         connect to the device
 
@@ -389,25 +372,23 @@ def connect(self, connect_data=b""):
         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:
-            self.user_packet_size = 72  # default zk8
+            self.user_packet_size = 72 # default zk8
         self.__create_socket()
         self.__session_id = 0
         self.__reply_id = const.USHRT_MAX - 1
         cmd_response = self.__send_command(const.CMD_CONNECT, connect_data)
         self.__session_id = self.__header[2]
-        if cmd_response.get("code") == const.CMD_ACK_UNAUTH:
-            if self.verbose:
-                print("try auth")
+        if cmd_response.get('code') == const.CMD_ACK_UNAUTH:
+            if self.verbose: print ("try auth")
             command_string = make_commkey(self.__password, self.__session_id)
             cmd_response = self.__send_command(const.CMD_AUTH, command_string)
-        if cmd_response.get("status"):
+        if cmd_response.get('status'):
             self.is_connect = True
             return self
         else:
             if cmd_response["code"] == const.CMD_ACK_UNAUTH:
                 raise ZKErrorResponse("Unauthenticated")
-            if self.verbose:
-                print("connect err response {} ".format(cmd_response["code"]))
+            if self.verbose: print ("connect err response {} ".format(cmd_response["code"]))
             raise ZKErrorResponse("Invalid response: Can't connect")
 
     def disconnect(self):
@@ -417,7 +398,7 @@ def disconnect(self):
         :return: bool
         """
         cmd_response = self.__send_command(const.CMD_EXIT)
-        if cmd_response.get("status"):
+        if cmd_response.get('status'):
             self.is_connect = False
             if self.__sock:
                 self.__sock.close()
@@ -432,7 +413,7 @@ def enable_device(self):
         :return: bool
         """
         cmd_response = self.__send_command(const.CMD_ENABLEDEVICE)
-        if cmd_response.get("status"):
+        if cmd_response.get('status'):
             self.is_enabled = True
             return True
         else:
@@ -445,7 +426,7 @@ def disable_device(self):
         :return: bool
         """
         cmd_response = self.__send_command(const.CMD_DISABLEDEVICE)
-        if cmd_response.get("status"):
+        if cmd_response.get('status'):
             self.is_enabled = False
             return True
         else:
@@ -455,9 +436,9 @@ 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]
+        cmd_response = self.__send_command(const.CMD_GET_VERSION,b'', 1024)
+        if cmd_response.get('status'):
+            firmware_version = self.__data.split(b'\x00')[0]
             return firmware_version.decode()
         else:
             raise ZKErrorResponse("Can't read frimware version")
@@ -467,13 +448,13 @@ def get_serialnumber(self):
         :return: the serial number
         """
         command = const.CMD_OPTIONS_RRQ
-        command_string = b"~SerialNumber\x00"
+        command_string = b'~SerialNumber\x00'
         response_size = 1024
         cmd_response = self.__send_command(command, command_string, response_size)
-        if cmd_response.get("status"):
-            serialnumber = self.__data.split(b"=", 1)[-1].split(b"\x00")[0]
-            serialnumber = serialnumber.replace(b"=", b"")
-            return serialnumber.decode()  # string?
+        if cmd_response.get('status'):
+            serialnumber = self.__data.split(b'=', 1)[-1].split(b'\x00')[0]
+            serialnumber = serialnumber.replace(b'=', b'')
+            return serialnumber.decode() # string?
         else:
             raise ZKErrorResponse("Can't read serial number")
 
@@ -482,13 +463,13 @@ def get_platform(self):
         :return: the platform name
         """
         command = const.CMD_OPTIONS_RRQ
-        command_string = b"~Platform\x00"
+        command_string = b'~Platform\x00'
         response_size = 1024
 
         cmd_response = self.__send_command(command, command_string, response_size)
-        if cmd_response.get("status"):
-            platform = self.__data.split(b"=", 1)[-1].split(b"\x00")[0]
-            platform = platform.replace(b"=", b"")
+        if cmd_response.get('status'):
+            platform = self.__data.split(b'=', 1)[-1].split(b'\x00')[0]
+            platform = platform.replace(b'=', b'')
             return platform.decode()
         else:
             raise ZKErrorResponse("Can't read platform name")
@@ -498,12 +479,12 @@ def get_mac(self):
         :return: the machine's mac address
         """
         command = const.CMD_OPTIONS_RRQ
-        command_string = b"MAC\x00"
+        command_string = b'MAC\x00'
         response_size = 1024
 
         cmd_response = self.__send_command(command, command_string, response_size)
-        if cmd_response.get("status"):
-            mac = self.__data.split(b"=", 1)[-1].split(b"\x00")[0]
+        if cmd_response.get('status'):
+            mac = self.__data.split(b'=', 1)[-1].split(b'\x00')[0]
             return mac.decode()
         else:
             raise ZKErrorResponse("can't read mac address")
@@ -515,12 +496,12 @@ def get_device_name(self):
         :return: str
         """
         command = const.CMD_OPTIONS_RRQ
-        command_string = b"~DeviceName\x00"
+        command_string = b'~DeviceName\x00'
         response_size = 1024
 
         cmd_response = self.__send_command(command, command_string, response_size)
-        if cmd_response.get("status"):
-            device = self.__data.split(b"=", 1)[-1].split(b"\x00")[0]
+        if cmd_response.get('status'):
+            device = self.__data.split(b'=', 1)[-1].split(b'\x00')[0]
             return device.decode()
         else:
             return ""
@@ -530,13 +511,13 @@ def get_face_version(self):
         :return: the face version
         """
         command = const.CMD_OPTIONS_RRQ
-        command_string = b"ZKFaceVersion\x00"
+        command_string = b'ZKFaceVersion\x00'
         response_size = 1024
 
         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]
-            return safe_cast(response, int, 0) if response else 0
+        if cmd_response.get('status'):
+            response = self.__data.split(b'=', 1)[-1].split(b'\x00')[0]
+            return safe_cast(response, int, 0)  if response else 0
         else:
             return None
 
@@ -545,18 +526,18 @@ def get_fp_version(self):
         :return: the fingerprint version
         """
         command = const.CMD_OPTIONS_RRQ
-        command_string = b"~ZKFPVersion\x00"
+        command_string = b'~ZKFPVersion\x00'
         response_size = 1024
 
         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]
-            response = response.replace(b"=", b"")
+        if cmd_response.get('status'):
+            response = self.__data.split(b'=', 1)[-1].split(b'\x00')[0]
+            response = response.replace(b'=', b'')
             return safe_cast(response, int, 0) if response else 0
         else:
             raise ZKErrorResponse("can't read fingerprint version")
 
-    def _clear_error(self, command_string=b""):
+    def _clear_error(self, command_string=b''):
         """
         clear ACK_error
         """
@@ -570,12 +551,12 @@ def get_extend_fmt(self):
         determine extend fmt
         """
         command = const.CMD_OPTIONS_RRQ
-        command_string = b"~ExtendFmt\x00"
+        command_string = b'~ExtendFmt\x00'
         response_size = 1024
 
         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]
+        if cmd_response.get('status'):
+            fmt = (self.__data.split(b'=', 1)[-1].split(b'\x00')[0])
             return safe_cast(fmt, int, 0) if fmt else 0
         else:
             self._clear_error(command_string)
@@ -586,12 +567,12 @@ def get_user_extend_fmt(self):
         determine user extend fmt
         """
         command = const.CMD_OPTIONS_RRQ
-        command_string = b"~UserExtFmt\x00"
+        command_string = b'~UserExtFmt\x00'
         response_size = 1024
 
         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]
+        if cmd_response.get('status'):
+            fmt = (self.__data.split(b'=', 1)[-1].split(b'\x00')[0])
             return safe_cast(fmt, int, 0) if fmt else 0
         else:
             self._clear_error(command_string)
@@ -602,13 +583,13 @@ def get_face_fun_on(self):
         determine extend fmt
         """
         command = const.CMD_OPTIONS_RRQ
-        command_string = b"FaceFunOn\x00"
+        command_string = b'FaceFunOn\x00'
         response_size = 1024
 
         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]
-            return safe_cast(response, int, 0) if response else 0
+        if cmd_response.get('status'):
+            response = (self.__data.split(b'=', 1)[-1].split(b'\x00')[0])
+            return safe_cast(response, int ,0) if response else 0
         else:
             self._clear_error(command_string)
             return None
@@ -618,12 +599,12 @@ def get_compat_old_firmware(self):
         determine old firmware
         """
         command = const.CMD_OPTIONS_RRQ
-        command_string = b"CompatOldFirmware\x00"
+        command_string = b'CompatOldFirmware\x00'
         response_size = 1024
 
         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]
+        if cmd_response.get('status'):
+            response = (self.__data.split(b'=', 1)[-1].split(b'\x00')[0])
             return safe_cast(response, int, 0) if response else 0
         else:
             self._clear_error(command_string)
@@ -634,33 +615,29 @@ def get_network_params(self):
         get network params
         """
         ip = self.__address[0]
-        mask = b""
-        gate = b""
-        cmd_response = self.__send_command(
-            const.CMD_OPTIONS_RRQ, b"IPAddress\x00", 1024
-        )
-        if cmd_response.get("status"):
-            ip = self.__data.split(b"=", 1)[-1].split(b"\x00")[0]
-        cmd_response = self.__send_command(const.CMD_OPTIONS_RRQ, b"NetMask\x00", 1024)
-        if cmd_response.get("status"):
-            mask = self.__data.split(b"=", 1)[-1].split(b"\x00")[0]
-        cmd_response = self.__send_command(
-            const.CMD_OPTIONS_RRQ, b"GATEIPAddress\x00", 1024
-        )
-        if cmd_response.get("status"):
-            gate = self.__data.split(b"=", 1)[-1].split(b"\x00")[0]
-        return {"ip": ip.decode(), "mask": mask.decode(), "gateway": gate.decode()}
+        mask = b''
+        gate = b''
+        cmd_response = self.__send_command(const.CMD_OPTIONS_RRQ, b'IPAddress\x00', 1024)
+        if cmd_response.get('status'):
+            ip = (self.__data.split(b'=', 1)[-1].split(b'\x00')[0])
+        cmd_response = self.__send_command(const.CMD_OPTIONS_RRQ, b'NetMask\x00', 1024)
+        if cmd_response.get('status'):
+            mask = (self.__data.split(b'=', 1)[-1].split(b'\x00')[0])
+        cmd_response = self.__send_command(const.CMD_OPTIONS_RRQ, b'GATEIPAddress\x00', 1024)
+        if cmd_response.get('status'):
+            gate = (self.__data.split(b'=', 1)[-1].split(b'\x00')[0])
+        return {'ip': ip.decode(), 'mask': mask.decode(), 'gateway': gate.decode()}
 
     def get_pin_width(self):
         """
         :return: the PIN width
         """
         command = const.CMD_GET_PINWIDTH
-        command_string = b" P"
+        command_string = b' P'
         response_size = 9
         cmd_response = self.__send_command(command, command_string, response_size)
-        if cmd_response.get("status"):
-            width = self.__data.split(b"\x00")[0]
+        if cmd_response.get('status'):
+            width = self.__data.split(b'\x00')[0]
             return bytearray(width)[0]
         else:
             raise ZKErrorResponse("can0t get pin width")
@@ -673,7 +650,7 @@ def free_data(self):
         """
         command = const.CMD_FREE_DATA
         cmd_response = self.__send_command(command)
-        if cmd_response.get("status"):
+        if cmd_response.get('status'):
             return True
         else:
             raise ZKErrorResponse("can't free data")
@@ -684,17 +661,16 @@ def read_sizes(self):
         """
         command = const.CMD_GET_FREE_SIZES
         response_size = 1024
-        cmd_response = self.__send_command(command, b"", response_size)
-        if cmd_response.get("status"):
-            if self.verbose:
-                print(codecs.encode(self.__data, "hex"))
+        cmd_response = self.__send_command(command,b'', response_size)
+        if cmd_response.get('status'):
+            if self.verbose: print(codecs.encode(self.__data,'hex'))
             size = len(self.__data)
             if len(self.__data) >= 80:
-                fields = unpack("20i", self.__data[:80])
+                fields = unpack('20i', self.__data[:80])
                 self.users = fields[4]
                 self.fingers = fields[6]
                 self.records = fields[8]
-                self.dummy = fields[10]  # ???
+                self.dummy = fields[10] #???
                 self.cards = fields[12]
                 self.fingers_cap = fields[14]
                 self.users_cap = fields[15]
@@ -703,10 +679,8 @@ def read_sizes(self):
                 self.users_av = fields[18]
                 self.rec_av = fields[19]
                 self.__data = self.__data[80:]
-            if len(self.__data) >= 12:  # face info
-                fields = unpack(
-                    "3i", self.__data[:12]
-                )  # dirty hack! we need more information
+            if len(self.__data) >= 12: #face info
+                fields = unpack('3i', self.__data[:12]) #dirty hack! we need more information
                 self.faces = fields[0]
                 self.faces_cap = fields[2]
             return True
@@ -722,21 +696,20 @@ def unlock(self, time=3):
         :return: bool
         """
         command = const.CMD_UNLOCK
-        command_string = pack("I", int(time) * 10)
+        command_string = pack("I",int(time)*10)
         cmd_response = self.__send_command(command, command_string)
-        if cmd_response.get("status"):
+        if cmd_response.get('status'):
             return True
         else:
             raise ZKErrorResponse("Can't open door")
-
     def get_lock_state(self):
-        """
+        '''
         :return: boolean
         thanks to https://github.com/icarome/pyzk/
-        """
+        '''
         command = const.CMD_DOORSTATE_RRQ
         cmd_response = self.__send_command(command)
-        if cmd_response.get("status"):
+        if cmd_response.get('status'):
             return True
         else:
             return False
@@ -745,22 +718,12 @@ def __str__(self):
         """
         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,
-                self.fingers,
-                self.fingers_cap,
-                self.records,
-                self.rec_cap,
-                self.faces,
-                self.faces_cap,
-            )
+        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,
+            self.fingers, self.fingers_cap,
+            self.records, self.rec_cap,
+            self.faces, self.faces_cap
         )
 
     def restart(self):
@@ -771,7 +734,7 @@ def restart(self):
         """
         command = const.CMD_RESTART
         cmd_response = self.__send_command(command)
-        if cmd_response.get("status"):
+        if cmd_response.get('status'):
             self.is_connect = False
             self.next_uid = 1
             return True
@@ -785,13 +748,9 @@ def write_lcd(self, line_number, text):
         :param text: text to write
         """
         command = const.CMD_WRITE_LCD
-        command_string = (
-            pack(b"<hb", line_number, 0)
-            + b" "
-            + text.encode(self.encoding, errors="ignore")
-        )
+        command_string = pack(b'<hb', line_number, 0) + b' ' + text.encode(self.encoding, errors='ignore')
         cmd_response = self.__send_command(command, command_string)
-        if cmd_response.get("status"):
+        if cmd_response.get('status'):
             return True
         else:
             raise ZKErrorResponse("can't write lcd")
@@ -802,7 +761,7 @@ def clear_lcd(self):
         """
         command = const.CMD_CLEAR_LCD
         cmd_response = self.__send_command(command)
-        if cmd_response.get("status"):
+        if cmd_response.get('status'):
             return True
         else:
             raise ZKErrorResponse("can't clear lcd")
@@ -813,8 +772,8 @@ def get_time(self):
         """
         command = const.CMD_GET_TIME
         response_size = 1032
-        cmd_response = self.__send_command(command, b"", response_size)
-        if cmd_response.get("status"):
+        cmd_response = self.__send_command(command, b'', response_size)
+        if cmd_response.get('status'):
             return self.__decode_time(self.__data[:4])
         else:
             raise ZKErrorResponse("can't get time")
@@ -826,9 +785,9 @@ def set_time(self, timestamp):
         :param timestamp: python datetime object
         """
         command = const.CMD_SET_TIME
-        command_string = pack(b"I", self.__encode_time(timestamp))
+        command_string = pack(b'I', self.__encode_time(timestamp))
         cmd_response = self.__send_command(command, command_string)
-        if cmd_response.get("status"):
+        if cmd_response.get('status'):
             return True
         else:
             raise ZKErrorResponse("can't set time")
@@ -838,10 +797,10 @@ def poweroff(self):
         shutdown the machine
         """
         command = const.CMD_POWEROFF
-        command_string = b""
+        command_string = b''
         response_size = 1032
         cmd_response = self.__send_command(command, command_string, response_size)
-        if cmd_response.get("status"):
+        if cmd_response.get('status'):
             self.is_connect = False
             self.next_uid = 1
             return True
@@ -851,7 +810,7 @@ def poweroff(self):
     def refresh_data(self):
         command = const.CMD_REFRESHDATA
         cmd_response = self.__send_command(command)
-        if cmd_response.get("status"):
+        if cmd_response.get('status'):
             return True
         else:
             raise ZKErrorResponse("can't refresh data")
@@ -922,21 +881,12 @@ def test_voice(self, index=0):
         command = const.CMD_TESTVOICE
         command_string = pack("I", index)
         cmd_response = self.__send_command(command, command_string)
-        if cmd_response.get("status"):
+        if cmd_response.get('status'):
             return True
         else:
             return False
 
-    def set_user(
-        self,
-        uid=None,
-        name="",
-        privilege=0,
-        password="",
-        group_id="",
-        user_id="",
-        card=0,
-    ):
+    def set_user(self, uid=None, name='', privilege=0, password='', group_id='', user_id='', card=0):
         """
         create or update user by uid
 
@@ -954,56 +904,32 @@ def set_user(
             if not user_id:
                 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...
+            user_id = str(uid) #ZK6 needs uid2 == uid
+        #TODO: check what happens if name is missing...
         if privilege not in [const.USER_DEFAULT, const.USER_ADMIN]:
             privilege = const.USER_DEFAULT
         privilege = int(privilege)
-        if self.user_packet_size == 28:  # self.firmware == 6:
+        if self.user_packet_size == 28: #self.firmware == 6:
             if not group_id:
                 group_id = 0
             try:
-                command_string = pack(
-                    "HB5s8sIxBHI",
-                    uid,
-                    privilege,
-                    password.encode(self.encoding, errors="ignore"),
-                    name.encode(self.encoding, errors="ignore"),
-                    card,
-                    int(group_id),
-                    0,
-                    int(user_id),
-                )
+                command_string = pack('HB5s8sIxBHI', uid, privilege, password.encode(self.encoding, errors='ignore'), name.encode(self.encoding, errors='ignore'), card, int(group_id), 0, int(user_id))
             except Exception as e:
-                if self.verbose:
-                    print("s_h Error pack: %s" % e)
-                if self.verbose:
-                    print("Error pack: %s" % sys.exc_info()[0])
+                if self.verbose: print("s_h Error pack: %s" % e)
+                if self.verbose: print("Error pack: %s" % sys.exc_info()[0])
                 raise ZKErrorResponse("Can't pack user")
         else:
-            name_pad = name.encode(self.encoding, errors="ignore").ljust(24, b"\x00")[
-                :24
-            ]
-            card_str = pack("<I", int(card))[:4]
-            command_string = pack(
-                "HB8s24s4sx7sx24s",
-                uid,
-                privilege,
-                password.encode(self.encoding, errors="ignore"),
-                name_pad,
-                card_str,
-                group_id.encode(),
-                user_id.encode(),
-            )
-        response_size = 1024  # TODO check response?
+            name_pad = name.encode(self.encoding, errors='ignore').ljust(24, b'\x00')[:24]
+            card_str = pack('<I', int(card))[:4]
+            command_string = pack('HB8s24s4sx7sx24s', uid, privilege, password.encode(self.encoding, errors='ignore'), name_pad, card_str, group_id.encode(), user_id.encode())
+        response_size = 1024 #TODO check response?
         cmd_response = self.__send_command(command, command_string, response_size)
-        if self.verbose:
-            print("Response: %s" % cmd_response)
-        if not cmd_response.get("status"):
+        if self.verbose: print("Response: %s" % cmd_response)
+        if not cmd_response.get('status'):
             raise ZKErrorResponse("Can't set user")
         self.refresh_data()
         if self.next_uid == uid:
-            self.next_uid += 1  # better recalculate again
+            self.next_uid += 1 # better recalculate again
         if self.next_user_id == user_id:
             self.next_user_id = str(self.next_uid)
 
@@ -1016,11 +942,11 @@ def save_user_template(self, user, fingers=[]):
         """
         if not isinstance(user, User):
             users = self.get_users()
-            tusers = list(filter(lambda x: x.uid == user, users))
+            tusers = list(filter(lambda x: x.uid==user, users))
             if len(tusers) == 1:
                 user = tusers[0]
             else:
-                tusers = list(filter(lambda x: x.user_id == str(user), users))
+                tusers = list(filter(lambda x: x.user_id==str(user), users))
                 if len(tusers) == 1:
                     user = tusers[0]
                 else:
@@ -1044,9 +970,9 @@ def save_user_template(self, user, fingers=[]):
         packet = head + upack + table + fpack
         self._send_with_buffer(packet)
         command = 110
-        command_string = pack("<IHH", 12, 0, 8)
+        command_string = pack('<IHH', 12,0,8)
         cmd_response = self.__send_command(command, command_string)
-        if not cmd_response.get("status"):
+        if not cmd_response.get('status'):
             raise ZKErrorResponse("Can't save utemp")
         self.refresh_data()
 
@@ -1055,28 +981,28 @@ def _send_with_buffer(self, buffer):
         size = len(buffer)
         self.free_data()
         command = const.CMD_PREPARE_DATA
-        command_string = pack("I", size)
+        command_string = pack('I', size)
         cmd_response = self.__send_command(command, command_string)
-        if not cmd_response.get("status"):
+        if not cmd_response.get('status'):
             raise ZKErrorResponse("Can't prepare data")
         remain = size % MAX_CHUNK
         packets = (size - remain) // MAX_CHUNK
         start = 0
         for _wlk in range(packets):
-            self.__send_chunk(buffer[start : start + MAX_CHUNK])
+            self.__send_chunk(buffer[start:start+MAX_CHUNK])
             start += MAX_CHUNK
         if remain:
-            self.__send_chunk(buffer[start : start + remain])
+            self.__send_chunk(buffer[start:start+remain])
 
     def __send_chunk(self, command_string):
         command = const.CMD_DATA
         cmd_response = self.__send_command(command, command_string)
-        if cmd_response.get("status"):
+        if cmd_response.get('status'):
             return True
         else:
             raise ZKErrorResponse("Can't send chunk")
 
-    def delete_user_template(self, uid=0, temp_id=0, user_id=""):
+    def delete_user_template(self, uid=0, temp_id=0, user_id=''):
         """
         Delete specific template
 
@@ -1086,27 +1012,27 @@ def delete_user_template(self, uid=0, temp_id=0, user_id=""):
         """
         if self.tcp and user_id:
             command = 134
-            command_string = pack("<24sB", str(user_id), temp_id)
+            command_string = pack('<24sB', str(user_id), temp_id)
             cmd_response = self.__send_command(command, command_string)
-            if cmd_response.get("status"):
+            if cmd_response.get('status'):
                 return True
             else:
-                return False  # probably empty!
+                return False # probably empty!
         if not uid:
             users = self.get_users()
-            users = list(filter(lambda x: x.user_id == str(user_id), users))
+            users = list(filter(lambda x: x.user_id==str(user_id), users))
             if not users:
                 return False
             uid = users[0].uid
         command = const.CMD_DELETE_USERTEMP
-        command_string = pack("hb", uid, temp_id)
+        command_string = pack('hb', uid, temp_id)
         cmd_response = self.__send_command(command, command_string)
-        if cmd_response.get("status"):
-            return True  # refres_data (1013)?
+        if cmd_response.get('status'):
+            return True #refres_data (1013)?
         else:
-            return False  # probably empty!
+            return False # probably empty!
 
-    def delete_user(self, uid=0, user_id=""):
+    def delete_user(self, uid=0, user_id=''):
         """
         delete specific user by uid or user_id
 
@@ -1116,20 +1042,20 @@ def delete_user(self, uid=0, user_id=""):
         """
         if not uid:
             users = self.get_users()
-            users = list(filter(lambda x: x.user_id == str(user_id), users))
+            users = list(filter(lambda x: x.user_id==str(user_id), users))
             if not users:
                 return False
             uid = users[0].uid
         command = const.CMD_DELETE_USER
-        command_string = pack("h", uid)
+        command_string = pack('h', uid)
         cmd_response = self.__send_command(command, command_string)
-        if not cmd_response.get("status"):
+        if not cmd_response.get('status'):
             raise ZKErrorResponse("Can't delete user")
         self.refresh_data()
         if uid == (self.next_uid - 1):
             self.next_uid = uid
 
-    def get_user_template(self, uid="", temp_id=0, user_id=""):
+    def get_user_template(self, uid = '', temp_id=0, user_id=''):
         """
         :param uid: user ID that are generated from device
         :param user_id: your own user ID
@@ -1137,26 +1063,24 @@ def get_user_template(self, uid="", temp_id=0, user_id=""):
         """
         if not uid:
             users = self.get_users()
-            users = list(filter(lambda x: x.user_id == str(user_id), users))
+            users = list(filter(lambda x: x.user_id==str(user_id), users))
             if not users:
                 return False
             uid = users[0].uid
         for _retries in range(3):
-            command = 88  # command secret!!! GET_USER_TEMPLATE
-            command_string = pack("hb", uid, temp_id)
+            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]
-                if resp[-6:] == b"\x00\x00\x00\x00\x00\x00":  # padding? bug?
+                if resp[-6:] == b'\x00\x00\x00\x00\x00\x00': # padding? bug?
                     resp = resp[:-6]
                 return Finger(uid, temp_id, 1, resp)
-            if self.verbose:
-                print("retry get_user_template")
+            if self.verbose: print ("retry get_user_template")
         else:
-            if self.verbose:
-                print("Can't read/find finger")
+            if self.verbose: print ("Can't read/find finger")
             return None
 
     def get_templates(self):
@@ -1167,27 +1091,18 @@ def get_templates(self):
         if self.fingers == 0:
             return []
         templates = []
-        templatedata, size = self.read_with_buffer(
-            const.CMD_DB_RRQ, const.FCT_FINGERTMP
-        )
+        templatedata, size = self.read_with_buffer(const.CMD_DB_RRQ, const.FCT_FINGERTMP)
         if size < 4:
-            if self.verbose:
-                print("WRN: no user data")
+            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)
-                )
-            )
+        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:]
         while total_size:
-            size, uid, fid, valid = unpack("HHbb", templatedata[:6])
-            template = unpack("%is" % (size - 6), templatedata[6:size])[0]
+            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)
+            if self.verbose: print(finger)
             templates.append(finger)
             templatedata = templatedata[size:]
             total_size -= size
@@ -1200,87 +1115,43 @@ def get_users(self):
         self.read_sizes()
         if self.users == 0:
             self.next_uid = 1
-            self.next_user_id = "1"
+            self.next_user_id='1'
             return []
         users = []
         max_uid = 0
         userdata, size = self.read_with_buffer(const.CMD_USERTEMP_RRQ, const.FCT_USER)
-        if self.verbose:
-            print("user size {} (= {})".format(size, len(userdata)))
+        if self.verbose: print("user size {} (= {})".format(size, len(userdata)))
         if size <= 4:
             print("WRN: missing user data")
             return []
-        total_size = unpack("I", userdata[:4])[0]
+        total_size = unpack("I",userdata[:4])[0]
         self.user_packet_size = total_size / self.users
         if not self.user_packet_size in [28, 72]:
-            if self.verbose:
-                print("WRN packet size would be  %i" % self.user_packet_size)
+            if self.verbose: print("WRN packet size would be  %i" % self.user_packet_size)
         userdata = userdata[4:]
         if self.user_packet_size == 28:
             while len(userdata) >= 28:
-                (
-                    uid,
-                    privilege,
-                    password,
-                    name,
-                    card,
-                    group_id,
-                    timezone,
-                    user_id,
-                ) = unpack("<HB5s8sIxBhI", userdata.ljust(28, b"\x00")[:28])
-                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()
-                )
+                uid, privilege, password, name, card, group_id, timezone, user_id = unpack('<HB5s8sIxBhI',userdata.ljust(28, b'\x00')[:28])
+                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()
                 group_id = str(group_id)
                 user_id = str(user_id)
-                # TODO: check card value and find in ver8
+                #TODO: check card value and find in ver8
                 if not name:
                     name = "NN-%s" % user_id
                 user = User(uid, name, privilege, password, group_id, user_id, card)
                 users.append(user)
-                if self.verbose:
-                    print(
-                        "[6]user:",
-                        uid,
-                        privilege,
-                        password,
-                        name,
-                        card,
-                        group_id,
-                        timezone,
-                        user_id,
-                    )
+                if self.verbose: print("[6]user:",uid, privilege, password, name, card, group_id, timezone, user_id)
                 userdata = userdata[28:]
         else:
             while len(userdata) >= 72:
-                uid, privilege, password, name, card, group_id, user_id = unpack(
-                    "<HB8s24sIx7sx24s", userdata.ljust(72, b"\x00")[:72]
-                )
-                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
+                uid, privilege, password, name, card, group_id, user_id = unpack('<HB8s24sIx7sx24s', userdata.ljust(72, b'\x00')[:72])
+                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
                 if not name:
                     name = "NN-%s" % user_id
                 user = User(uid, name, privilege, password, group_id, user_id, card)
@@ -1305,7 +1176,7 @@ def cancel_capture(self):
         """
         command = const.CMD_CANCELCAPTURE
         cmd_response = self.__send_command(command)
-        return bool(cmd_response.get("status"))
+        return bool(cmd_response.get('status'))
 
     def verify_user(self):
         """
@@ -1315,7 +1186,7 @@ def verify_user(self):
         """
         command = const.CMD_STARTVERIFY
         cmd_response = self.__send_command(command)
-        if cmd_response.get("status"):
+        if cmd_response.get('status'):
             return True
         else:
             raise ZKErrorResponse("Cant Verify")
@@ -1325,20 +1196,20 @@ def reg_event(self, flags):
         reg events
         """
         command = const.CMD_REG_EVENT
-        command_string = pack("I", flags)
+        command_string = pack ("I", flags)
         cmd_response = self.__send_command(command, command_string)
-        if not cmd_response.get("status"):
+        if not cmd_response.get('status'):
             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"):
+        if not cmd_response.get('status'):
             return False
         return True
 
-    def enroll_user(self, uid=0, temp_id=0, user_id=""):
+    def enroll_user(self, uid=0, temp_id=0, user_id=''):
         """
         start enroll user
 
@@ -1349,105 +1220,86 @@ def enroll_user(self, uid=0, temp_id=0, user_id=""):
         """
         command = const.CMD_STARTENROLL
         done = False
-        if not user_id:
+        if  not user_id:
             users = self.get_users()
-            users = list(filter(lambda x: x.uid == uid, users))
+            users = list(filter(lambda x: x.uid==uid, users))
             if len(users) >= 1:
                 user_id = users[0].user_id
             else:
                 return False
         if self.tcp:
-            command_string = pack("<24sbb", str(user_id).encode(), temp_id, 1)
+            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))
+        if not cmd_response.get('status'):
+            raise ZKErrorResponse("Cant Enroll user #%i [%i]" %(uid, temp_id))
         self.__sock.settimeout(60)
         attempts = 3
         while attempts:
-            if self.verbose:
-                print("A:%i esperando primer regevent" % attempts)
+            if self.verbose: print("A:%i esperando primer regevent" % attempts)
             data_recv = self.__sock.recv(1032)
             self.__ack_ok()
-            if self.verbose:
-                print(codecs.encode(data_recv, "hex"))
+            if self.verbose: print(codecs.encode(data_recv,'hex'))
             if self.tcp:
                 if len(data_recv) > 16:
-                    res = unpack("H", data_recv.ljust(24, b"\x00")[16:18])[0]
-                    if self.verbose:
-                        print("res %i" % res)
+                    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:
-                        if self.verbose:
-                            print("posible timeout  o reg Fallido")
+                        if self.verbose: print ("posible timeout  o reg Fallido")
                         break
             else:
                 if len(data_recv) > 8:
-                    res = unpack("H", data_recv.ljust(16, b"\x00")[8:10])[0]
-                    if self.verbose:
-                        print("res %i" % res)
+                    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")
+                        if self.verbose: print ("posible timeout")
                         break
-            if self.verbose:
-                print("A:%i esperando 2do regevent" % attempts)
+            if self.verbose: print ("A:%i esperando 2do regevent" % attempts)
             data_recv = self.__sock.recv(1032)
             self.__ack_ok()
-            if self.verbose:
-                print(codecs.encode(data_recv, "hex"))
+            if self.verbose: print (codecs.encode(data_recv, 'hex'))
             if self.tcp:
                 if len(data_recv) > 8:
-                    res = unpack("H", data_recv.ljust(24, b"\x00")[16:18])[0]
-                    if self.verbose:
-                        print("res %i" % res)
+                    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:
-                        if self.verbose:
-                            print("posible timeout  o reg Fallido")
+                        if self.verbose: print ("posible timeout  o reg Fallido")
                         break
                     elif res == 0x64:
-                        if self.verbose:
-                            print("ok, continue?")
+                        if self.verbose: print ("ok, continue?")
                         attempts -= 1
             else:
                 if len(data_recv) > 8:
-                    res = unpack("H", data_recv.ljust(16, b"\x00")[8:10])[0]
-                    if self.verbose:
-                        print("res %i" % res)
+                    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  o reg Fallido")
                         break
                     elif res == 0x64:
-                        if self.verbose:
-                            print("ok, continue?")
+                        if self.verbose: print ("ok, continue?")
                         attempts -= 1
         if attempts == 0:
             data_recv = self.__sock.recv(1032)
             self.__ack_ok()
-            if self.verbose:
-                print(codecs.encode(data_recv, "hex"))
+            if self.verbose: print (codecs.encode(data_recv, 'hex'))
             if self.tcp:
-                res = unpack("H", data_recv.ljust(24, b"\x00")[16:18])[0]
+                res = unpack("H", data_recv.ljust(24,b"\x00")[16:18])[0]
             else:
-                res = unpack("H", data_recv.ljust(16, b"\x00")[8:10])[0]
-            if self.verbose:
-                print("res %i" % res)
+                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("finger duplicate")
+                if self.verbose: print ("finger duplicate")
             if res == 6 or res == 4:
-                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]
-                if self.verbose:
-                    print("enroll ok", size, pos)
+                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]
+                if self.verbose: print("enroll ok", size, pos)
                 done = True
         self.__sock.settimeout(self.__timeout)
-        self.reg_event(0)  # TODO: test
+        self.reg_event(0) # TODO: test
         self.cancel_capture()
         self.verify_user()
         return done
@@ -1462,54 +1314,46 @@ def live_capture(self, new_timeout=10):
         self.verify_user()
         if not self.is_enabled:
             self.enable_device()
-        if self.verbose:
-            print("start live_capture")
+        if self.verbose: print ("start live_capture")
         self.reg_event(const.EF_ATTLOG)
         self.__sock.settimeout(new_timeout)
         self.end_live_capture = False
         while not self.end_live_capture:
             try:
-                if self.verbose:
-                    print("esperando event")
+                if self.verbose: print ("esperando event")
                 data_recv = self.__sock.recv(1032)
                 self.__ack_ok()
                 if self.tcp:
-                    size = unpack("<HHI", data_recv[:8])[2]
-                    header = unpack("HHHH", data_recv[8:16])
+                    size = unpack('<HHI', data_recv[:8])[2]
+                    header = unpack('HHHH', data_recv[8:16])
                     data = data_recv[16:]
                 else:
                     size = len(data_recv)
-                    header = unpack("<4H", data_recv[:8])
+                    header = unpack('<4H', data_recv[:8])
                     data = data_recv[8:]
                 if not header[0] == const.CMD_REG_EVENT:
-                    if self.verbose:
-                        print("not event! %x" % header[0])
+                    if self.verbose: print("not event! %x" % header[0])
                     continue
                 if not len(data):
-                    if self.verbose:
-                        print("empty")
+                    if self.verbose: print ("empty")
                     continue
                 while len(data) >= 12:
                     if len(data) == 12:
-                        user_id, status, punch, timehex = unpack("<IBB6s", data)
+                        user_id, status, punch, timehex = unpack('<IBB6s', data)
                         data = data[12:]
                     elif len(data) == 32:
-                        user_id, status, punch, timehex = unpack("<24sBB6s", data[:32])
+                        user_id,  status, punch, timehex = unpack('<24sBB6s', data[:32])
                         data = data[32:]
                     elif len(data) == 36:
-                        user_id, status, punch, timehex, _other = unpack(
-                            "<24sBB6s4s", data[:36]
-                        )
+                        user_id,  status, punch, timehex, _other = unpack('<24sBB6s4s', data[:36])
                         data = data[36:]
                     elif len(data) >= 52:
-                        user_id, status, punch, timehex, _other = unpack(
-                            "<24sBB6s20s", data[:52]
-                        )
+                        user_id,  status, punch, timehex, _other = unpack('<24sBB6s20s', data[:52])
                         data = data[52:]
                     if isinstance(user_id, int):
                         user_id = str(user_id)
                     else:
-                        user_id = (user_id.split(b"\x00")[0]).decode(errors="ignore")
+                        user_id = (user_id.split(b'\x00')[0]).decode(errors='ignore')
                     timestamp = self.__decode_timehex(timehex)
                     tuser = list(filter(lambda x: x.user_id == user_id, users))
                     if not tuser:
@@ -1518,15 +1362,12 @@ def live_capture(self, new_timeout=10):
                         uid = tuser[0].uid
                     yield Attendance(user_id, timestamp, status, punch, uid)
             except timeout:
-                if self.verbose:
-                    print("time out")
-                yield None  # return to keep watching
+                if self.verbose: print ("time out")
+                yield None # return to keep watching
             except (KeyboardInterrupt, SystemExit):
-                if self.verbose:
-                    print("break")
+                if self.verbose: print ("break")
                 break
-        if self.verbose:
-            print("exit gracefully")
+        if self.verbose: print ("exit gracefully")
         self.__sock.settimeout(self.__timeout)
         self.reg_event(0)
         if not was_enabled:
@@ -1539,124 +1380,96 @@ def clear_data(self):
         :return: bool
         """
         command = const.CMD_CLEAR_DATA
-        command_string = b""
+        command_string = b''
         cmd_response = self.__send_command(command, command_string)
-        if cmd_response.get("status"):
+        if cmd_response.get('status'):
             self.next_uid = 1
             return True
         else:
             raise ZKErrorResponse("can't clear data")
 
     def __recieve_tcp_data(self, data_recv, size):
-        """data_recv, raw tcp packet
-        must analyze tcp_length
+        """ data_recv, raw tcp packet
+         must analyze tcp_length
 
-        must return data, broken
-        """
+         must return data, broken
+         """
         data = []
         tcp_length = self.__test_tcp_top(data_recv)
-        if self.verbose:
-            print("tcp_length {}, size {}".format(tcp_length, size))
+        if self.verbose: print ("tcp_length {}, size {}".format(tcp_length, size))
         if tcp_length <= 0:
-            if self.verbose:
-                print("Incorrect tcp packet")
+            if self.verbose: print ("Incorrect tcp packet")
             return None, b""
         if (tcp_length - 8) < size:
-            if self.verbose:
-                print("tcp length too small... retrying")
+            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)
-            if self.verbose:
-                print("new tcp DATA starting with {} bytes".format(len(data_recv)))
+            if self.verbose: print ("new tcp DATA packet to fill misssing {}".format(size))
+            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)
-            if self.verbose:
-                print(
-                    "for misssing {} recieved {} with extra {}".format(
-                        size, len(resp), len(bh)
-                    )
-                )
-            return b"".join(data), bh
+            if self.verbose: print ("for misssing {} recieved {} with extra {}".format(size, len(resp), len(bh)))
+            return b''.join(data), bh
         recieved = len(data_recv)
-        if self.verbose:
-            print("recieved {}, size {}".format(recieved, size))
-        response = unpack("HHHH", data_recv[8:16])[0]
+        if self.verbose: print ("recieved {}, size {}".format(recieved, size))
+        response = unpack('HHHH', data_recv[8:16])[0]
         if recieved >= (size + 32):
             if response == const.CMD_DATA:
                 resp = data_recv[16 : size + 16]
-                if self.verbose:
-                    print("resp complete len {}".format(len(resp)))
-                return resp, data_recv[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))
+                if self.verbose: print("incorrect response!!! {}".format(response))
                 return None, b""
         else:
-            if self.verbose:
-                print("try DATA incomplete (actual valid {})".format(recieved - 16))
-            data.append(data_recv[16 : size + 16])
+            if self.verbose: print ("try DATA incomplete (actual valid {})".format(recieved-16))
+            data.append(data_recv[16 : size + 16 ])
             size -= recieved - 16
             broken_header = b""
             if size < 0:
                 broken_header = data_recv[size:]
-                if self.verbose:
-                    print("broken", (broken_header).encode("hex"))
+                if self.verbose: print ("broken", (broken_header).encode('hex'))
             if size > 0:
                 data_recv = self.__recieve_raw_data(size)
                 data.append(data_recv)
-            return b"".join(data), broken_header
+            return b''.join(data), broken_header
 
     def __recieve_raw_data(self, size):
-        """partial data ?"""
+        """ partial data ? """
         data = []
-        if self.verbose:
-            print("expecting {} bytes raw data".format(size))
+        if self.verbose: print ("expecting {} bytes raw data".format(size))
         while size > 0:
             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")))
+            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)
             size -= recieved
-            if self.verbose:
-                print("still need {}".format(size))
-        return b"".join(data)
+            if self.verbose: print ("still need {}".format(size))
+        return b''.join(data)
 
     def __recieve_chunk(self):
-        """recieve a chunk"""
+        """ recieve a chunk """
         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 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))
+                    if self.verbose: print ("need more data: {}".format(need))
                     more_data = self.__recieve_raw_data(need)
-                    return b"".join([self.__data, more_data])
+                    return b''.join([self.__data, more_data])
                 else:
-                    if self.verbose:
-                        print("Enough data")
+                    if self.verbose: print ("Enough data")
                     return self.__data
             else:
-                if self.verbose:
-                    print("_rc len is {}".format(len(self.__data)))
+                if self.verbose: print ("_rc len is {}".format(len(self.__data)))
                 return self.__data
         elif self.__response == const.CMD_PREPARE_DATA:
             data = []
             size = self.__get_data_size()
-            if self.verbose:
-                print("recieve chunk: prepare data size is {}".format(size))
+            if self.verbose: print ("recieve chunk: prepare data size is {}".format(size))
             if self.tcp:
                 if len(self.__data) >= (8 + size):
                     data_recv = self.__data[8:]
@@ -1670,48 +1483,37 @@ def __recieve_chunk(self):
                 else:
                     data_recv = broken_header
                 if len(data_recv) < 16:
-                    print("trying to complete broken ACK %s /16" % len(data_recv))
-                    if self.verbose:
-                        print(data_recv.encode("hex"))
-                    data_recv += self.__sock.recv(
-                        16 - len(data_recv)
-                    )  # TODO: CHECK HERE_!
+                    print ("trying to complete broken ACK %s /16" % len(data_recv))
+                    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")
+                    if self.verbose: print ("invalid chunk tcp ACK OK")
                     return None
-                response = unpack("HHHH", data_recv[8:16])[0]
+                response = unpack('HHHH', data_recv[8:16])[0]
                 if response == const.CMD_ACK_OK:
-                    if self.verbose:
-                        print("chunk tcp ACK OK!")
-                    return b"".join(data)
-                if self.verbose:
-                    print("bad response %s" % data_recv)
-                if self.verbose:
-                    print(codecs.encode(data, "hex"))
+                    if self.verbose: print ("chunk tcp ACK OK!")
+                    return b''.join(data)
+                if self.verbose: print("bad response %s" % data_recv)
+                if self.verbose: print (codecs.encode(data,'hex'))
                 return None
 
                 return resp
             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))
+                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:])
                     size -= 1024
                 elif response == const.CMD_ACK_OK:
                     break
                 else:
-                    if self.verbose:
-                        print("broken!")
+                    if self.verbose: print ("broken!")
                     break
-                if self.verbose:
-                    print("still needs %s" % size)
-            return b"".join(data)
+                if self.verbose: print ("still needs %s" % size)
+            return b''.join(data)
         else:
-            if self.verbose:
-                print("invalid response %s" % self.__response)
+            if self.verbose: print ("invalid response %s" % self.__response)
             return None
 
     def __read_chunk(self, start, size):
@@ -1720,7 +1522,7 @@ def __read_chunk(self, start, size):
         """
         for _retries in range(3):
             command = 1504
-            command_string = pack("<ii", start, size)
+            command_string = pack('<ii', start, size)
             if self.tcp:
                 response_size = size + 32
             else:
@@ -1732,68 +1534,51 @@ def __read_chunk(self, start, size):
         else:
             raise ZKErrorResponse("can't read chunk %i:[%i]" % (start, size))
 
-    def read_with_buffer(self, command, fct=0, ext=0):
+    def read_with_buffer(self, command, fct=0 ,ext=0):
         """
         Test read info with buffered command (ZK6: 1503)
         """
         if self.tcp:
-            MAX_CHUNK = 0xFFC0
+            MAX_CHUNK = 0xFFc0
         else:
             MAX_CHUNK = 16 * 1024
-        command_string = pack("<bhii", 1, command, fct, ext)
-        if self.verbose:
-            print("rwb cs", command_string)
+        command_string = pack('<bhii', 1, command, fct, ext)
+        if self.verbose: print ("rwb cs", command_string)
         response_size = 1024
         data = []
         start = 0
         cmd_response = self.__send_command(1503, command_string, response_size)
-        if not cmd_response.get("status"):
+        if not cmd_response.get('status'):
             raise ZKErrorResponse("RWB Not supported")
-        if cmd_response["code"] == const.CMD_DATA:
+        if cmd_response['code'] == const.CMD_DATA:
             if self.tcp:
-                if self.verbose:
-                    print(
-                        "DATA! is {} bytes, tcp length is {}".format(
-                            len(self.__data), self.__tcp_length
-                        )
-                    )
+                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))
+                    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
-                    )
+                    return b''.join([self.__data, more_data]), len(self.__data) + len(more_data)
                 else:
-                    if self.verbose:
-                        print("Enough data")
+                    if self.verbose: print ("Enough data")
                     size = len(self.__data)
                     return self.__data, size
             else:
                 size = len(self.__data)
                 return self.__data, size
-        size = unpack("I", self.__data[1:5])[0]
-        if self.verbose:
-            print("size fill be %i" % size)
+        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
-        if self.verbose:
-            print(
-                "rwb: #{} packets of max {} bytes, and extra {} bytes remain".format(
-                    packets, MAX_CHUNK, remain
-                )
-            )
+        packets = (size-remain) // MAX_CHUNK # should be size /16k
+        if self.verbose: print ("rwb: #{} packets of max {} bytes, and extra {} bytes remain".format(packets, MAX_CHUNK, remain))
         for _wlk in range(packets):
-            data.append(self.__read_chunk(start, MAX_CHUNK))
+            data.append(self.__read_chunk(start,MAX_CHUNK))
             start += MAX_CHUNK
         if remain:
             data.append(self.__read_chunk(start, remain))
             start += remain
         self.free_data()
-        if self.verbose:
-            print("_read w/chunk %i bytes" % start)
-        return b"".join(data), start
+        if self.verbose: print ("_read w/chunk %i bytes" % start)
+        return b''.join(data), start
 
     def get_attendance(self):
         """
@@ -1805,26 +1590,20 @@ def get_attendance(self):
         if self.records == 0:
             return []
         users = self.get_users()
-        if self.verbose:
-            print(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")
+            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)
+        record_size = total_size/self.records
+        if self.verbose: print ("record_size is ", record_size)
         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"))
+                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:
@@ -1836,17 +1615,13 @@ def get_attendance(self):
                 attendances.append(attendance)
         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, 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"))
+                if self.verbose: print(codecs.encode(attendance_data[:16], 'hex'))
                 attendance_data = attendance_data[16:]
                 tuser = list(filter(lambda x: x.user_id == user_id, users))
                 if not tuser:
-                    if self.verbose:
-                        print("no uid {}", user_id)
+                    if self.verbose: print("no uid {}", user_id)
                     uid = str(user_id)
                     tuser = list(filter(lambda x: x.uid == user_id, users))
                     if not tuser:
@@ -1861,12 +1636,9 @@ def get_attendance(self):
                 attendances.append(attendance)
         else:
             while len(attendance_data) >= 40:
-                uid, user_id, status, timestamp, punch, space = unpack(
-                    "<H24sB4sB8s", attendance_data.ljust(40, b"\x00")[:40]
-                )
-                if self.verbose:
-                    print(codecs.encode(attendance_data[:40], "hex"))
-                user_id = (user_id.split(b"\x00")[0]).decode(errors="ignore")
+                uid, user_id, status, timestamp, punch, space = unpack('<H24sB4sB8s', attendance_data.ljust(40, b'\x00')[:40])
+                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)
 
                 attendance = Attendance(user_id, timestamp, status, punch, uid)
@@ -1882,7 +1654,7 @@ def clear_attendance(self):
         """
         command = const.CMD_CLEAR_ATTLOG
         cmd_response = self.__send_command(command)
-        if cmd_response.get("status"):
+        if cmd_response.get('status'):
             return True
         else:
             raise ZKErrorResponse("Can't clear response")