Update app.py

app.py

@@ -36,25 +36,21 @@ def butter_bandpass(sr, order=5):
     Returns:
     tuple: The filter coefficients `b` and `a`.
     """
-    try:
-        # Calculate the Nyquist frequency
-        nyquist = 0.5 * sr
+    # Calculate the Nyquist frequency
+    nyquist = 0.5 * sr
 
-        # Normalize the cutoff frequencies
-        low = low_frequency / nyquist
-        high = high_frequency / nyquist
+    # Normalize the cutoff frequencies
+    low = low_frequency / nyquist
+    high = high_frequency / nyquist
 
-        # Design the Butterworth bandpass filter
-        coefficient = butter(order, [low, high], btype='band')
+    # Design the Butterworth bandpass filter
+    coefficient = butter(order, [low, high], btype='band')
 
-        # Extract the filter coefficients
-        b = coefficient[0]
-        a = coefficient[1]
+    # Extract the filter coefficients
+    b = coefficient[0]
+    a = coefficient[1]
 
-        return b, a
-    except Exception as e:
-        # If an error occurs, return an error message
-        return f"Error: {str(e)}"
+    return b, a
 
 
 def butter_bandpass_filter(data, sr, order=5):
@@ -69,17 +65,13 @@ def butter_bandpass_filter(data, sr, order=5):
     Returns:
     array: The filtered audio data.
     """
-    try:
-        # Get the filter coefficients
-        b, a = butter_bandpass(sr, order=order)
+    # Get the filter coefficients
+    b, a = butter_bandpass(sr, order=order)
 
-        # Apply the filter to the data
-        y = lfilter(b, a, data)
+    # Apply the filter to the data
+    y = lfilter(b, a, data)
 
-        return y
-    except Exception as e:
-        # If an error occurs, return an error message
-        return f"Error: {str(e)}"
+    return y
 
 
 def filtered():
@@ -261,21 +253,17 @@ def dominant_frequency(signal_value):
     Returns:
     float: The dominant frequency.
     """
-    try:
-        # Perform a Fast Fourier Transform on the signal
-        yf = fft(signal_value)
+    # Perform a Fast Fourier Transform on the signal
+    yf = fft(signal_value)
 
-        # Generate the frequencies corresponding to the FFT coefficients
-        xf = np.linspace(0.0, sample_rate / 2.0, len(signal_value) // 2)
+    # Generate the frequencies corresponding to the FFT coefficients
+    xf = np.linspace(0.0, sample_rate / 2.0, len(signal_value) // 2)
 
-        # Find the peaks in the absolute values of the FFT coefficients
-        peaks, _ = find_peaks(np.abs(yf[0:len(signal_value) // 2]))
+    # Find the peaks in the absolute values of the FFT coefficients
+    peaks, _ = find_peaks(np.abs(yf[0:len(signal_value) // 2]))
 
-        # Return the frequency corresponding to the peak with the highest amplitude
-        return xf[peaks[np.argmax(np.abs(yf[0:len(signal_value) // 2][peaks]))]]
-    except Exception as e:
-        # If an error occurs, return an error message
-        return f"Error: {e}"
+    # Return the frequency corresponding to the peak with the highest amplitude
+    return xf[peaks[np.argmax(np.abs(yf[0:len(signal_value) // 2][peaks]))]]
 
 
 def binary_to_text(binary):
@@ -291,9 +279,9 @@ def binary_to_text(binary):
     try:
         # Convert each 8-bit binary number to a character and join them together
         return ''.join(chr(int(binary[i:i + 8], 2)) for i in range(0, len(binary), 8))
-    except ValueError:
+    except Exception as e:
         # If an error occurs, return an error message
-        return f"Error: Invalid binary number '{binary}'"
+        return f"Error: {e}"
 
 
 def decode_rs(binary_string, ecc_bytes):
@@ -307,27 +295,23 @@ def decode_rs(binary_string, ecc_bytes):
     Returns:
     str: The decoded binary string.
     """
-    try:
-        # Convert the binary string to a bytearray
-        byte_data = bytearray(int(binary_string[i:i + 8], 2) for i in range(0, len(binary_string), 8))
+    # Convert the binary string to a bytearray
+    byte_data = bytearray(int(binary_string[i:i + 8], 2) for i in range(0, len(binary_string), 8))
 
-        # Initialize a Reed-Solomon codec
-        rs = reedsolo.RSCodec(ecc_bytes)
+    # Initialize a Reed-Solomon codec
+    rs = reedsolo.RSCodec(ecc_bytes)
 
-        # Decode the bytearray
-        corrected_data_tuple = rs.decode(byte_data)
-        corrected_data = corrected_data_tuple[0]
+    # Decode the bytearray
+    corrected_data_tuple = rs.decode(byte_data)
+    corrected_data = corrected_data_tuple[0]
 
-        # Remove trailing null bytes
-        corrected_data = corrected_data.rstrip(b'\x00')
+    # Remove trailing null bytes
+    corrected_data = corrected_data.rstrip(b'\x00')
 
-        # Convert the bytearray back to a binary string
-        corrected_binary_string = ''.join(format(byte, '08b') for byte in corrected_data)
+    # Convert the bytearray back to a binary string
+    corrected_binary_string = ''.join(format(byte, '08b') for byte in corrected_data)
 
-        return corrected_binary_string
-    except Exception as e:
-        # If an error occurs, return an error message
-        return f"Error: {e}"
+    return corrected_binary_string
 
 
 def manchester_decoding(binary_string):
@@ -340,21 +324,17 @@ def manchester_decoding(binary_string):
     Returns:
     str: The decoded binary string.
     """
-    try:
-        decoded_string = ''
-        for i in tqdm(range(0, len(binary_string), 2), desc="Decoding"):
-            if i + 1 < len(binary_string):
-                if binary_string[i] == '0' and binary_string[i + 1] == '1':
-                    decoded_string += '0'
-                elif binary_string[i] == '1' and binary_string[i + 1] == '0':
-                    decoded_string += '1'
-                else:
-                    print("Error: Invalid Manchester Encoding")
-                    return None
-        return decoded_string
-    except Exception as e:
-        # If an error occurs, return an error message
-        return f"Error: {e}"
+    decoded_string = ''
+    for i in tqdm(range(0, len(binary_string), 2), desc="Decoding"):
+        if i + 1 < len(binary_string):
+            if binary_string[i] == '0' and binary_string[i + 1] == '1':
+                decoded_string += '0'
+            elif binary_string[i] == '1' and binary_string[i + 1] == '0':
+                decoded_string += '1'
+            else:
+                print("Error: Invalid Manchester Encoding")
+                return None
+    return decoded_string
 
 
 def signal_to_binary_between_times(filename):
@@ -367,47 +347,43 @@ def signal_to_binary_between_times(filename):
     Returns:
     str: The binary string.
     """
-    try:
-        # Get the start and end times of the signal of interest
-        start_time, end_time = frame_analyse(filename)
-
-        # Read the audio file
-        sr, data = read(filename)
-
-        # Calculate the start and end samples of the signal of interest
-        start_sample = int((start_time - 0.007) * sr)
-        end_sample = int((end_time - 0.007) * sr)
-        binary_string = ''
-
-        # Convert each sample to a binary digit
-        for i in tqdm(range(start_sample, end_sample, int(sr * bit_duration))):
-            signal_value = data[i:i + int(sr * bit_duration)]
-            frequency = dominant_frequency(signal_value)
-            if np.abs(frequency - low_frequency) < np.abs(frequency - high_frequency):
-                binary_string += '0'
-            else:
-                binary_string += '1'
-
-        # Find the start and end indices of the binary string
-        index_start = binary_string.find("1000001")
-        substrings = ["0111110", "011110"]
-        index_end = -1
-        for substring in substrings:
-            index = binary_string.find(substring)
-            if index != -1:
-                index_end = index
-                break
-
-        print("Binary String:", binary_string)
-        binary_string_decoded = manchester_decoding(binary_string[index_start + 7:index_end])
-
-        # Decode the binary string
-        decoded_binary_string = decode_rs(binary_string_decoded, 20)
-
-        return decoded_binary_string
-    except Exception as e:
-        # If an error occurs, return an error message
-        return f"Error: {e}"
+    # Get the start and end times of the signal of interest
+    start_time, end_time = frame_analyse(filename)
+
+    # Read the audio file
+    sr, data = read(filename)
+
+    # Calculate the start and end samples of the signal of interest
+    start_sample = int((start_time - 0.007) * sr)
+    end_sample = int((end_time - 0.007) * sr)
+    binary_string = ''
+
+    # Convert each sample to a binary digit
+    for i in tqdm(range(start_sample, end_sample, int(sr * bit_duration))):
+        signal_value = data[i:i + int(sr * bit_duration)]
+        frequency = dominant_frequency(signal_value)
+        if np.abs(frequency - low_frequency) < np.abs(frequency - high_frequency):
+            binary_string += '0'
+        else:
+            binary_string += '1'
+
+    # Find the start and end indices of the binary string
+    index_start = binary_string.find("1000001")
+    substrings = ["0111110", "011110"]
+    index_end = -1
+    for substring in substrings:
+        index = binary_string.find(substring)
+        if index != -1:
+            index_end = index
+            break
+
+    print("Binary String:", binary_string)
+    binary_string_decoded = manchester_decoding(binary_string[index_start + 7:index_end])
+
+    # Decode the binary string
+    decoded_binary_string = decode_rs(binary_string_decoded, 20)
+
+    return decoded_binary_string
 
 
 def receive():