rbzk 0.1.0 → 0.1.2

data/lib/rbzk/zk.rb

@@ -5,7 +5,7 @@ require 'timeout'
 require 'date'
 
 module RBZK
-  # Helper class for ZK (like Python's ZK_helper)
+  # Helper class for ZK
   class ZKHelper
     def initialize(ip, port = 4370)
       @ip = ip
@@ -14,7 +14,6 @@ module RBZK
     end
 
     def test_ping
-      # Like Python's test_ping
       begin
         system("ping -c 1 -W 5 #{@ip} > /dev/null 2>&1")
         return $?.success?
@@ -24,34 +23,23 @@ module RBZK
     end
 
     def test_tcp
-      # Match Python's test_tcp method exactly
       begin
-        # Create socket like Python's socket(AF_INET, SOCK_STREAM)
         client = Socket.new(Socket::AF_INET, Socket::SOCK_STREAM)
-
-        # Set timeout like Python's settimeout(10)
         client.setsockopt(Socket::SOL_SOCKET, Socket::SO_RCVTIMEO, [ 10, 0 ].pack('l_*'))
 
-        # Use connect_ex like Python (returns error code instead of raising exception)
         sockaddr = Socket.pack_sockaddr_in(@port, @ip)
         begin
           client.connect(sockaddr)
-          result = 0 # Success, like Python's connect_ex returns 0 on success
+          result = 0 # Success code
         rescue Errno::EISCONN
-          # Already connected
-          result = 0
+          result = 0 # Already connected
         rescue => e
-          # Connection failed, return error code
-          result = e.errno || 1
+          result = e.errno || 1 # Connection failed
         end
 
-        # Close socket
         client.close
-
-        # Return result code (0 = success, non-zero = error)
         return result
       rescue => e
-        # Something went wrong with socket creation
         return e.errno || 1
       end
     end
@@ -61,7 +49,7 @@ module RBZK
     include RBZK::Constants
 
     def initialize(ip, port: 4370, timeout: 60, password: 0, force_udp: false, omit_ping: false, verbose: false, encoding: 'UTF-8')
-      # Match Python's __init__ method
+      # Initialize the ZK device connection
       RBZK::User.encoding = encoding
       @address = [ ip, port ]
 
@@ -74,13 +62,10 @@ module RBZK
       @verbose = verbose
       @encoding = encoding
 
-      # Set TCP mode based on force_udp (like Python's self.tcp = not force_udp)
       @tcp = !force_udp
-
-      # Socket will be created during connect
       @socket = nil
 
-      # Initialize session variables (like Python)
+      # Initialize session variables
       @session_id = 0
       @reply_id = USHRT_MAX - 1
       @data_recv = nil
@@ -94,7 +79,7 @@ module RBZK
       @fingers = {}
       @tcp_header_size = 8
 
-      # Initialize device info variables (like Python)
+      # Initialize device info variables
       @users = 0
       @fingers = 0
       @records = 0
@@ -118,60 +103,44 @@ module RBZK
       end
     end
 
-    # Remove this method as we now use the helper class
-    # def test_tcp
-    # end
-
     def connect
-      # Match Python's connect method
       return self if @connected
 
-      # Skip ping check if requested (like Python's ommit_ping)
+      # Skip ping check if requested
       if !@omit_ping && !@helper.test_ping
         raise RBZK::ZKNetworkError, "Can't reach device (ping #{@ip})"
       end
 
-      # Test TCP connection (like Python's connect)
+      # Set user packet size if TCP connection is available
       if !@force_udp && @helper.test_tcp == 0
-        # Default user packet size for ZK8
-        @user_packet_size = 72
+        @user_packet_size = 72 # Default for ZK8
       end
 
-      # Create socket (like Python's __create_socket)
       create_socket
 
-      # Reset session variables (like Python's connect)
+      # Reset session variables
       @session_id = 0
       @reply_id = USHRT_MAX - 1
 
-      # Send connect command (like Python's connect)
       if @verbose
         puts "Sending connect command to device"
       end
 
       begin
-        # Send connect command (like Python's connect)
-        # In Python: cmd_response = self.__send_command(const.CMD_CONNECT)
-        # No command string is needed for the connect command
         cmd_response = send_command(CMD_CONNECT)
-
-        # Update session ID from header (like Python's connect)
         @session_id = @header[2]
 
-        # Authenticate if needed (like Python's connect)
+        # Authenticate if needed
         if cmd_response[:code] == CMD_ACK_UNAUTH
           if @verbose
             puts "try auth"
           end
 
-          # Create auth command string (like Python's make_commkey)
           command_string = make_commkey(@password, @session_id)
-
-          # Send auth command
           cmd_response = send_command(CMD_AUTH, command_string)
         end
 
-        # Check response status (like Python's connect)
+        # Check response status
         if cmd_response[:status]
           @connected = true
           return self
@@ -221,63 +190,29 @@ module RBZK
     end
 
     def disable_device
-      # Match Python's disable_device method exactly
-      # In Python:
-      # def disable_device(self):
-      #     cmd_response = self.__send_command(const.CMD_DISABLEDEVICE)
-      #     if cmd_response.get('status'):
-      #         self.is_enabled = False
-      #         return True
-      #     else:
-      #         raise ZKErrorResponse("Can't disable device")
-
       cmd_response = self.send_command(CMD_DISABLEDEVICE)
       if cmd_response[:status]
         @is_enabled = false
-        return true
+        true
       else
         raise RBZK::ZKErrorResponse, "Can't disable device"
       end
     end
 
     def get_firmware_version
-      # Match Python's get_firmware_version method exactly
-      # In Python:
-      # def get_firmware_version(self):
-      #     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")
-
       command = CMD_GET_VERSION
       response_size = 1024
       response = self.send_command(command, "", response_size)
 
       if response && response[:status]
         firmware_version = @data.split("\x00")[0]
-        return firmware_version.to_s
+        firmware_version.to_s
       else
         raise RBZK::ZKErrorResponse, "Can't read firmware version"
       end
     end
 
     def get_serialnumber
-      # Match Python's get_serialnumber method exactly
-      # In Python:
-      # def get_serialnumber(self):
-      #     command = const.CMD_OPTIONS_RRQ
-      #     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?
-      #     else:
-      #         raise ZKErrorResponse("Can't read serial number")
-
       command = CMD_OPTIONS_RRQ
       command_string = "~SerialNumber\x00".b
       response_size = 1024
@@ -287,26 +222,13 @@ module RBZK
       if response && response[:status]
         serialnumber = @data.split("=", 2)[1]&.split("\x00")[0] || ""
         serialnumber = serialnumber.gsub("=", "")
-        return serialnumber.to_s
+        serialnumber.to_s
       else
         raise RBZK::ZKErrorResponse, "Can't read serial number"
       end
     end
 
     def get_mac
-      # Match Python's get_mac method exactly
-      # In Python:
-      # def get_mac(self):
-      #     command = const.CMD_OPTIONS_RRQ
-      #     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]
-      #         return mac.decode()
-      #     else:
-      #         raise ZKErrorResponse("can't read mac address")
-
       command = CMD_OPTIONS_RRQ
       command_string = "MAC\x00".b
       response_size = 1024
@@ -315,26 +237,13 @@ module RBZK
 
       if response && response[:status]
         mac = @data.split("=", 2)[1]&.split("\x00")[0] || ""
-        return mac.to_s
+        mac.to_s
       else
         raise RBZK::ZKErrorResponse, "Can't read MAC address"
       end
     end
 
     def get_device_name
-      # Match Python's get_device_name method exactly
-      # In Python:
-      # def get_device_name(self):
-      #     command = const.CMD_OPTIONS_RRQ
-      #     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]
-      #         return device.decode()
-      #     else:
-      #         return ""
-
       command = CMD_OPTIONS_RRQ
       command_string = "~DeviceName\x00".b
       response_size = 1024
@@ -343,26 +252,13 @@ module RBZK
 
       if response && response[:status]
         device = @data.split("=", 2)[1]&.split("\x00")[0] || ""
-        return device.to_s
+        device.to_s
       else
-        return ""
+        ""
       end
     end
 
     def get_face_version
-      # Match Python's get_face_version method exactly
-      # In Python:
-      # def get_face_version(self):
-      #     command = const.CMD_OPTIONS_RRQ
-      #     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
-      #     else:
-      #         return None
-
       command = CMD_OPTIONS_RRQ
       command_string = "ZKFaceVersion\x00".b
       response_size = 1024
@@ -371,27 +267,13 @@ module RBZK
 
       if response && response[:status]
         version = @data.split("=", 2)[1]&.split("\x00")[0] || ""
-        return version.to_i rescue 0
+        version.to_i rescue 0
       else
-        return nil
+        nil
       end
     end
 
     def get_extend_fmt
-      # Match Python's get_extend_fmt method exactly
-      # In Python:
-      # def get_extend_fmt(self):
-      #     command = const.CMD_OPTIONS_RRQ
-      #     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])
-      #         return safe_cast(fmt, int, 0) if fmt else 0
-      #     else:
-      #         self._clear_error(command_string)
-      #         return None
-
       command = CMD_OPTIONS_RRQ
       command_string = "~ExtendFmt\x00".b
       response_size = 1024
@@ -400,29 +282,13 @@ module RBZK
 
       if response && response[:status]
         fmt = @data.split("=", 2)[1]&.split("\x00")[0] || ""
-        return fmt.to_i rescue 0
+        fmt.to_i rescue 0
       else
-        # In Python, this would call self._clear_error(command_string)
-        # We don't have that method, so we'll just return nil
-        return nil
+        nil
       end
     end
 
     def get_platform
-      # Match Python's get_platform method exactly
-      # In Python:
-      # def get_platform(self):
-      #     command = const.CMD_OPTIONS_RRQ
-      #     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'')
-      #         return platform.decode()
-      #     else:
-      #         raise ZKErrorResponse("Can't read platform name")
-
       command = CMD_OPTIONS_RRQ
       command_string = "~Platform\x00".b
       response_size = 1024
@@ -432,27 +298,13 @@ module RBZK
       if response && response[:status]
         platform = @data.split("=", 2)[1]&.split("\x00")[0] || ""
         platform = platform.gsub("=", "")
-        return platform.to_s
+        platform.to_s
       else
         raise RBZK::ZKErrorResponse, "Can't read platform name"
       end
     end
 
     def get_fp_version
-      # Match Python's get_fp_version method exactly
-      # In Python:
-      # def get_fp_version(self):
-      #     command = const.CMD_OPTIONS_RRQ
-      #     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'')
-      #         return safe_cast(response, int, 0) if response else 0
-      #     else:
-      #         raise ZKErrorResponse("can't read fingerprint version")
-
       command = CMD_OPTIONS_RRQ
       command_string = "~ZKFPVersion\x00".b
       response_size = 1024
@@ -462,7 +314,7 @@ module RBZK
       if response && response[:status]
         version = @data.split("=", 2)[1]&.split("\x00")[0] || ""
         version = version.gsub("=", "")
-        return version.to_i rescue 0
+        version.to_i rescue 0
       else
         raise RBZK::ZKErrorResponse, "Can't read fingerprint version"
       end
@@ -481,76 +333,18 @@ module RBZK
     end
 
     def test_voice(index = 0)
-      # Match Python's test_voice method exactly
-      # In Python:
-      # 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'):
-      #         return True
-      #     else:
-      #         return False
-
       command_string = [ index ].pack('L<')
       response = self.send_command(CMD_TESTVOICE, command_string)
 
       if response && response[:status]
-        return true
+        true
       else
-        return false
+        false
       end
     end
 
-    # Helper method to read data with buffer, similar to Python's read_with_buffer
+    # Helper method to read data with buffer (ZK6: 1503)
     def read_with_buffer(command, fct = 0, ext = 0)
-      # Match Python's read_with_buffer method exactly
-      # In Python:
-      # def read_with_buffer(self, command, fct=0 ,ext=0):
-      #     """
-      #     Test read info with buffered command (ZK6: 1503)
-      #     """
-      #     if self.tcp:
-      #         MAX_CHUNK = 0xFFc0
-      #     else:
-      #         MAX_CHUNK = 16 * 1024
-      #     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(const._CMD_PREPARE_BUFFER, command_string, response_size)
-      #     if not cmd_response.get('status'):
-      #         raise ZKErrorResponse("RWB Not supported")
-      #     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 len(self.__data) < (self.__tcp_length - 8):
-      #                 need = (self.__tcp_length - 8) - len(self.__data)
-      #                 if self.verbose: print ("need more data: {}".format(need))
-      #                 more_data = self.__recieve_raw_data(need)
-      #                 return b''.join([self.__data, more_data]), len(self.__data) + len(more_data)
-      #             else:
-      #                 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)
-      #     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))
-      #     for _wlk in range(packets):
-      #         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 @verbose
         puts "Reading data with buffer: command=#{command}, fct=#{fct}, ext=#{ext}"
@@ -559,27 +353,16 @@ module RBZK
       # Set max chunk size based on connection type
       max_chunk = @tcp ? 0xFFc0 : 16 * 1024
 
-      # In Python: command_string = pack('<bhii', 1, command, fct, ext)
-      # Note: In Python, the format '<bhii' means:
-      # < - little endian
-      # b - signed char (1 byte)
-      # h - short (2 bytes)
-      # i - int (4 bytes)
-      # i - int (4 bytes)
-      # In Ruby, we need to use:
-      # c - signed char (1 byte) to match Python's 'b'
-      # s - short (2 bytes)
-      # l - long (4 bytes)
-      # l - long (4 bytes)
-      # with < for little-endian
+      # Pack the command parameters into a binary string
+      # Format: 1 byte signed char, 2 byte short, 4 byte long, 4 byte long
+      # All in little-endian format
       command_string = [ 1, command, fct, ext ].pack('cs<l<l<')
 
       if @verbose
         puts "Command string: #{python_format(command_string)}"
       end
 
-      # In Python: cmd_response = self.__send_command(const._CMD_PREPARE_BUFFER, command_string, response_size)
-      # Note: In Python, const._CMD_PREPARE_BUFFER is 1503
+      # Send the command to prepare the buffer
       response_size = 1024
       data = []
       start = 0
@@ -609,7 +392,7 @@ module RBZK
               puts "need more data: #{need}"
             end
 
-            # In Python: more_data = self.__recieve_raw_data(need)
+            # Receive more data to complete the buffer
             more_data = receive_raw_data(need)
 
             if @verbose
@@ -632,9 +415,7 @@ module RBZK
         end
       end
 
-      # Get the size from the first 4 bytes
-      # In Python: size = unpack('I', self.__data[1:5])[0]
-      # In Ruby, 'L<' is an unsigned long (4 bytes) in little-endian format, which matches Python's 'I'
+      # Get the size from the first 4 bytes (unsigned long, little-endian)
       size = data[1..4].unpack('L<')[0]
 
       if @verbose
@@ -643,8 +424,7 @@ module RBZK
 
       # Calculate chunks
       remain = size % max_chunk
-      # In Python: packets = (size-remain) // MAX_CHUNK # should be size /16k
-      # In Ruby, we need to use integer division to match Python's // operator
+      # Calculate number of full-sized packets (integer division)
       packets = (size - remain).div(max_chunk)
 
       if @verbose
@@ -682,72 +462,19 @@ module RBZK
 
       # In Python: return b''.join(data), start
       result = result_data.join
-      return result, start
+      [ result, start ]
     end
 
     # Helper method to get data size from the current data
     def get_data_size
-      # Match Python's __get_data_size method exactly
-      # In Python:
-      # def __get_data_size(self):
-      #     """internal function to get data size from the packet"""
-      #     if len(self.__data) >= 4:
-      #         size = unpack('I', self.__data[:4])[0]
-      #         return size
-      #     else:
-      #         return 0
-
       if @data && @data.size >= 4
         size = @data[0...4].unpack('L<')[0]
-        return size
+        size
       else
-        return 0
+        0
       end
     end
 
-    # Helper method to test TCP header
-    def test_tcp_top(data)
-      # Match Python's __test_tcp_top method exactly
-      # In Python:
-      # def __test_tcp_top(self, packet):
-      #     """test a TCP packet header"""
-      #     if not packet:
-      #         return False
-      #     if len(packet) < 8:
-      #         self.__tcp_length = 0
-      #         self.__response = const.CMD_TCP_STILL_ALIVE
-      #         return True
-      #
-      #     if len(packet) < 8:
-      #         self.__tcp_length = 0
-      #         self.__response = const.CMD_TCP_STILL_ALIVE
-      #         return True
-      #     top, self.__session_id, self.__reply_id, self.__tcp_length = unpack('<HHHI', packet[:8])
-      #     self.__response = top
-      #     if self.verbose: print ("tcp top is {}, session id is {}, reply id is {}, tcp length is {}".format(
-      #         self.__response, self.__session_id, self.__reply_id, self.__tcp_length))
-      #     return True
-
-      if !data || data.empty?
-        return false
-      end
-
-      if data.size < 8
-        @tcp_length = 0
-        @response = CMD_TCP_STILL_ALIVE
-        return true
-      end
-
-      top, @session_id, @reply_id, @tcp_length = data[0...8].unpack('S<S<S<L<')
-      @response = top
-
-      if @verbose
-        puts "tcp top is #{@response}, session id is #{@session_id}, reply id is #{@reply_id}, tcp length is #{@tcp_length}"
-      end
-
-      return true
-    end
-
     # Helper method to receive TCP data
     def receive_tcp_data(data_recv, size)
       data = []
@@ -940,28 +667,12 @@ module RBZK
         if @verbose
           puts "invalid response #{@response}"
         end
-        return nil
+        nil
       end
     end
 
     # Helper method to receive raw data (like Python's __recieve_raw_data)
     def receive_raw_data(size)
-      # Match Python's __recieve_raw_data method exactly
-      # In Python:
-      # def __recieve_raw_data(self, size):
-      #     """ partial data ? """
-      #     data = []
-      #     if self.verbose: print ("expecting {} bytes raw data".format(size))
-      #     while size > 0:
-      #         data_recv = self.__sock.recv(size)
-      #         recieved = len(data_recv)
-      #         if self.verbose: print ("partial recv {}".format(recieved))
-      #         if recieved < 100 and self.verbose: print ("   recv {}".format(codecs.encode(data_recv, 'hex')))
-      #         data.append(data_recv)
-      #         size -= recieved
-      #         if self.verbose: print ("still need {}".format(size))
-      #     return b''.join(data)
-
       data = []
       if @verbose
         puts "expecting #{size} bytes raw data"
@@ -991,26 +702,11 @@ module RBZK
 
     # Helper method to clear buffer (like Python's free_data)
     def free_data
-      # Match Python's free_data method exactly
-      # In Python:
-      # def free_data(self):
-      #     """
-      #     clear buffer
-      #
-      #     :return: bool
-      #     """
-      #     command = const.CMD_FREE_DATA
-      #     cmd_response = self.__send_command(command)
-      #     if cmd_response.get('status'):
-      #         return True
-      #     else:
-      #         raise ZKErrorResponse("can't free data")
-
       command = CMD_FREE_DATA
       response = self.send_command(command)
 
       if response && response[:status]
-        return true
+        true
       else
         raise RBZK::ZKErrorResponse, "Can't free data"
       end
@@ -1018,26 +714,6 @@ module RBZK
 
     # Helper method to read a chunk of data
     def read_chunk(start, size)
-      # Match Python's __read_chunk method exactly
-      # In Python:
-      # def __read_chunk(self, start, size):
-      #     """
-      #     read a chunk from buffer
-      #     """
-      #     for _retries in range(3):
-      #         command = const._CMD_READ_BUFFER
-      #         command_string = pack('<ii', start, size)
-      #         if self.tcp:
-      #             response_size = size + 32
-      #         else:
-      #             response_size = 1024 + 8
-      #         cmd_response = self.__send_command(command, command_string, response_size)
-      #         data = self.__recieve_chunk()
-      #         if data is not None:
-      #             return data
-      #     else:
-      #         raise ZKErrorResponse("can't read chunk %i:[%i]" % (start, size))
-
       if @verbose
         puts "Reading chunk: start=#{start}, size=#{size}"
       end
@@ -1157,68 +833,6 @@ module RBZK
     end
 
     def get_attendance_logs
-      # Match Python's get_attendance method exactly
-      # In Python:
-      # def get_attendance(self):
-      #     self.read_sizes()
-      #     if self.records == 0:
-      #         return []
-      #     users = self.get_users()
-      #     if self.verbose: print (users)
-      #     attendances = []
-      #     attendance_data, size = self.read_with_buffer(const.CMD_ATTLOG_RRQ)
-      #     if size < 4:
-      #         if self.verbose: print ("WRN: no attendance data")
-      #         return []
-      #     total_size = unpack("I", attendance_data[:4])[0]
-      #     record_size = total_size // self.records
-      #     if self.verbose: print ("record_size is ", record_size)
-      #     attendance_data = attendance_data[4:]
-      #     if record_size == 8:
-      #         while len(attendance_data) >= 8:
-      #             uid, status, timestamp, punch = unpack('HB4sB', attendance_data.ljust(8, b'\x00')[:8])
-      #             if self.verbose: print (codecs.encode(attendance_data[:8], 'hex'))
-      #             attendance_data = attendance_data[8:]
-      #             tuser = list(filter(lambda x: x.uid == uid, users))
-      #             if not tuser:
-      #                 user_id = str(uid)
-      #             else:
-      #                 user_id = tuser[0].user_id
-      #             timestamp = self.__decode_time(timestamp)
-      #             attendance = Attendance(user_id, timestamp, status, punch, uid)
-      #             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 = str(user_id)
-      #             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)
-      #                 uid = str(user_id)
-      #                 tuser = list(filter(lambda x: x.uid == user_id, users))
-      #                 if not tuser:
-      #                     uid = str(user_id)
-      #                 else:
-      #                     uid = tuser[0].uid
-      #                     user_id = tuser[0].user_id
-      #             else:
-      #                 uid = tuser[0].uid
-      #             timestamp = self.__decode_time(timestamp)
-      #             attendance = Attendance(user_id, timestamp, status, punch, uid)
-      #             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')
-      #             timestamp = self.__decode_time(timestamp)
-      #             attendance = Attendance(user_id, timestamp, status, punch, uid)
-      #             attendances.append(attendance)
-      #             attendance_data = attendance_data[record_size:]
-      #     return attendances
-
       # First, read device sizes to get record count
       self.read_sizes
 
@@ -1353,31 +967,6 @@ module RBZK
       logs
     end
 
-    # Decode a timestamp retrieved from the timeclock
-    # Match Python's __decode_time method exactly
-    # In Python:
-    # def __decode_time(self, t):
-    #     t = unpack("<I", t)[0]
-    #     second = t % 60
-    #     t = t // 60
-    #
-    #     minute = t % 60
-    #     t = t // 60
-    #
-    #     hour = t % 24
-    #     t = t // 24
-    #
-    #     day = t % 31 + 1
-    #     t = t // 31
-    #
-    #     month = t % 12 + 1
-    #     t = t // 12
-    #
-    #     year = t + 2000
-    #
-    #     d = datetime(year, month, day, hour, minute, second)
-    #
-    #     return d
     def decode_time(t)
       # Convert binary timestamp to integer
       t = t.unpack("L<")[0]
@@ -1406,12 +995,6 @@ module RBZK
 
     # Decode a timestamp in hex format (6 bytes)
     # Match Python's __decode_timehex method
-    # In Python:
-    # def __decode_timehex(self, timehex):
-    #     year, month, day, hour, minute, second = unpack("6B", timehex)
-    #     year += 2000
-    #     d = datetime(year, month, day, hour, minute, second)
-    #     return d
     def decode_timehex(timehex)
       # Extract time components
       year, month, day, hour, minute, second = timehex.unpack("C6")
@@ -1421,15 +1004,6 @@ module RBZK
       Time.new(year, month, day, hour, minute, second)
     end
 
-    # Encode a timestamp for the device
-    # Match Python's __encode_time method
-    # In Python:
-    # def __encode_time(self, t):
-    #     d = (
-    #         ((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 encode_time(t)
       # Calculate encoded timestamp
       d = (
@@ -1440,40 +1014,18 @@ module RBZK
     end
 
     def get_time
-      # Match Python's get_time method exactly
-      # In Python:
-      # 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'):
-      #         return self.__decode_time(self.__data[:4])
-      #     else:
-      #         raise ZKErrorResponse("can't get time")
-
       command = CMD_GET_TIME
       response_size = 1032
       response = self.send_command(command, "", response_size)
 
       if response && response[:status]
-        return decode_time(@data[0...4])
+        decode_time(@data[0...4])
       else
         raise RBZK::ZKErrorResponse, "Can't get time"
       end
     end
 
     def set_time(timestamp = nil)
-      # Match Python's set_time method exactly
-      # In Python:
-      # def set_time(self, timestamp):
-      #     command = const.CMD_SET_TIME
-      #     command_string = pack(b'I', self.__encode_time(timestamp))
-      #     cmd_response = self.__send_command(command, command_string)
-      #     if cmd_response.get('status'):
-      #         return True
-      #     else:
-      #         raise ZKErrorResponse("can't set time")
-
       # Default to current time if not provided
       timestamp ||= Time.now
 
@@ -1482,7 +1034,7 @@ module RBZK
       response = self.send_command(command, command_string)
 
       if response && response[:status]
-        return true
+        true
       else
         raise RBZK::ZKErrorResponse, "Can't set time"
       end
@@ -1608,30 +1160,6 @@ module RBZK
     end
 
     def read_sizes
-      # Match Python's read_sizes method exactly
-      # In Python:
-      # 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'))
-      #         size = len(self.__data)
-      #         if len(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.cards = fields[12]
-      #             self.fingers_cap = fields[14]
-      #             self.users_cap = fields[15]
-      #             self.rec_cap = fields[16]
-      #             self.fingers_av = fields[17]
-      #             self.users_av = fields[18]
-      #             self.rec_av = fields[19]
-      #             self.__data = self.__data[80:]
-
       command = CMD_GET_FREE_SIZES
       response_size = 1024
       cmd_response = self.send_command(command, "", response_size)
@@ -1841,7 +1369,7 @@ module RBZK
       end
 
       # Default return 0
-      return 0
+      0
     end
 
     def ping
@@ -1894,26 +1422,6 @@ module RBZK
     end
 
     def calculate_checksum(buf)
-      # Match Python's __create_checksum method exactly
-      # In Python:
-      # def __create_checksum(self, p):
-      #     l = len(p)
-      #     checksum = 0
-      #     while l > 1:
-      #         checksum += unpack('H', pack('BB', p[0], p[1]))[0]
-      #         p = p[2:]
-      #         if checksum > const.USHRT_MAX:
-      #             checksum -= const.USHRT_MAX
-      #         l -= 2
-      #     if l:
-      #         checksum = checksum + p[-1]
-      #     while checksum > const.USHRT_MAX:
-      #         checksum -= const.USHRT_MAX
-      #     checksum = ~checksum
-      #     while checksum < 0:
-      #         checksum += const.USHRT_MAX
-      #     return pack('H', checksum)
-
       # Get the length of the buffer
       l = buf.size
       checksum = 0
@@ -1970,94 +1478,42 @@ module RBZK
     end
 
     def create_tcp_top(packet)
-      # Match Python's __create_tcp_top method exactly
       puts "\n*** DEBUG: create_tcp_top called ***" if @verbose
       length = packet.size
-      # In Python: pack('<HHI', const.MACHINE_PREPARE_DATA_1, const.MACHINE_PREPARE_DATA_2, length)
-      # In Ruby: [MACHINE_PREPARE_DATA_1, MACHINE_PREPARE_DATA_2, length].pack('S<S<I<')
       top = [ MACHINE_PREPARE_DATA_1, MACHINE_PREPARE_DATA_2, length ].pack('S<S<I<')
 
       if @verbose
-        puts "\nTCP header components:"
-        puts "  MACHINE_PREPARE_DATA_1: 0x#{MACHINE_PREPARE_DATA_1.to_s(16)} (#{MACHINE_PREPARE_DATA_1}) - should be 'PP' in ASCII"
-        puts "  MACHINE_PREPARE_DATA_2: 0x#{MACHINE_PREPARE_DATA_2.to_s(16)} (#{MACHINE_PREPARE_DATA_2}) - should be '\\x82\\x7d' in hex"
+        puts "TCP header components:"
+        puts "  MACHINE_PREPARE_DATA_1: 0x#{MACHINE_PREPARE_DATA_1.to_s(16)}"
+        puts "  MACHINE_PREPARE_DATA_2: 0x#{MACHINE_PREPARE_DATA_2.to_s(16)}"
         puts "  packet length: #{length}"
-
-        # Show the expected Python representation
-        expected_python_header = "PP\\x82\\x7d\\x#{(length & 0xFF).to_s(16).rjust(2, '0')}\\x#{((length >> 8) & 0xFF).to_s(16).rjust(2, '0')}\\x#{((length >> 16) & 0xFF).to_s(16).rjust(2, '0')}\\x#{((length >> 24) & 0xFF).to_s(16).rjust(2, '0')}"
-        puts "  Expected Python header: #{expected_python_header}"
-
-        # Show the actual bytes of the constants
-        puts "  MACHINE_PREPARE_DATA_1 bytes: #{[ MACHINE_PREPARE_DATA_1 ].pack('S<').bytes.map { |b| "0x#{b.to_s(16).rjust(2, '0')}" }.join(' ')}"
-        puts "  MACHINE_PREPARE_DATA_2 bytes: #{[ MACHINE_PREPARE_DATA_2 ].pack('S<').bytes.map { |b| "0x#{b.to_s(16).rjust(2, '0')}" }.join(' ')}"
-
-        debug_binary("TCP header only", top) # This is just the 8-byte header
-        debug_binary("Full TCP packet (what Python calls 'top')", top + packet) # This is what we return
-      end
-
-      # Print debug info right before returning
-      if @verbose
-        puts "\n*** FINAL TCP PACKET DEBUG ***"
-        puts "In both Python and Ruby, the variable 'top' is just the TCP header, but the method returns 'top + packet':"
-        puts "TCP header format: b'PP\\x82\\x7d\\x#{(length & 0xFF).to_s(16).rjust(2, '0')}\\x#{((length >> 8) & 0xFF).to_s(16).rjust(2, '0')}\\x#{((length >> 16) & 0xFF).to_s(16).rjust(2, '0')}\\x#{((length >> 24) & 0xFF).to_s(16).rjust(2, '0')}'"
-        puts "Return value format (top + packet): TCP header + command packet"
-        puts "Ruby 'top + packet' format: #{(top + packet).bytes.map { |b| "0x#{b.to_s(16).rjust(2, '0')}" }.join(' ')}"
-        puts "Hex format: #{(top + packet).bytes.map { |b| "\\x#{b.to_s(16).rjust(2, '0')}" }.join('')}"
+        debug_binary("TCP header", top)
+        debug_binary("Full TCP packet", top + packet)
       end
 
-      # Return top + packet (like Python's return top + packet)
-      result = top + packet
-
-      if @verbose
-        puts "\n*** SUPER EXPLICIT DEBUG ***"
-        puts "top bytes: #{top.bytes.map { |b| "0x#{b.to_s(16).rjust(2, '0')}" }.join(' ')}"
-        puts "packet bytes: #{packet.bytes.map { |b| "0x#{b.to_s(16).rjust(2, '0')}" }.join(' ')}"
-        puts "result bytes: #{result.bytes.map { |b| "0x#{b.to_s(16).rjust(2, '0')}" }.join(' ')}"
-        puts "result size: #{result.size} bytes"
-      end
-
-      result
+      top + packet
     end
 
     def create_header(command, command_string = "".b, session_id = 0, reply_id = 0)
-      # Match Python's __create_header method exactly
-      # In Python:
-      # def __create_header(self, command, command_string, session_id, reply_id):
-      #     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)
-      #     return buf + command_string
-
       # Ensure command_string is a binary string
       command_string = command_string.to_s.b
 
-      # Step 1: Create initial header and combine with command_string
-      # In Python: buf = pack('<4H', command, 0, session_id, reply_id) + command_string
+      # Create initial header and combine with command_string
       buf = [ command, 0, session_id, reply_id ].pack('v4') + command_string
 
-      # Step 2: Convert to bytes array for checksum calculation
-      # In Python: buf = unpack('8B' + '%sB' % len(command_string), buf)
-      # This unpacks the buffer into individual bytes
-      # In Ruby, we can use String#bytes to get an array of bytes
+      # Convert to bytes array for checksum calculation
       buf = buf.unpack("C#{8 + command_string.length}")
 
-      # Step 3: Calculate checksum
-      # In Python: checksum = unpack('H', self.__create_checksum(buf))[0]
+      # Calculate checksum
       checksum = calculate_checksum(buf)
 
-      # Step 4: Update reply_id
-      # In Python: reply_id += 1; if reply_id >= const.USHRT_MAX: reply_id -= const.USHRT_MAX
+      # Update reply_id
       reply_id += 1
       if reply_id >= USHRT_MAX
         reply_id -= USHRT_MAX
       end
 
-      # Step 5: Create final header with updated values
-      # In Python: buf = pack('<4H', command, checksum, session_id, reply_id)
+      # Create final header with updated values
       buf = [ command, checksum, session_id, reply_id ].pack('v4')
 
       if @verbose
@@ -2079,41 +1535,6 @@ module RBZK
     end
 
     def send_command(command, command_string = "".b, response_size = 8)
-      # Match Python's __send_command method exactly
-      # In Python:
-      # def __send_command(self, command, command_string=b'', response_size=8):
-      #     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)
-      #     try:
-      #         if self.tcp:
-      #             top = self.__create_tcp_top(buf)
-      #             self.__sock.send(top)
-      #             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])
-      #     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
-      #     }
-
       # Check connection status (except for connect and auth commands)
       if command != CMD_CONNECT && command != CMD_AUTH && !@connected
         raise RBZK::ZKErrorConnection, "Instance are not connected."
@@ -2190,12 +1611,12 @@ module RBZK
 
       # Return response status (like Python's __send_command)
       if @response == CMD_ACK_OK || @response == CMD_PREPARE_DATA || @response == CMD_DATA
-        return {
+        {
           status: true,
           code: @response
         }
       else
-        return {
+        {
           status: false,
           code: @response
         }