tictacsync 0.1a10__py2-none-any.whl → 0.1a11__py2-none-any.whl

tictacsync/device_scanner.py

@@ -173,11 +173,11 @@ class Scanner:
                 continue
             devices = [m['dev UID'] for m in media_same_length]
             if len(set(devices)) !=1:
-                print('files with same length but diff device?')
+                print('There are files with same length but from different devices?')
                 for media in media_same_length:
-                    print(' %s'%media['path'])
-                print('put the offending file in its own folder and')
-                print('rerun. Quitting...')
+                    print(' [gold1]%s[/gold1]'%media['path'])
+                print('Please put the offending file in its own folder and rerun.')
+                print('Quitting...')
                 quit()
             self.found_multifiles.append(media_same_length)
         self.found_media_files = unifile_recordings
@@ -326,6 +326,13 @@ class Scanner:
 
         Returns nothing
         """
+        def _list_duplicates(seq):
+          seen = set()
+          seen_add = seen.add
+          # adds all elements it doesn't know yet to seen and all other to seen_twice
+          seen_twice = set( x for x in seq if x in seen or seen_add(x) )
+          # turn the set into a list (as requested)
+          return list( seen_twice )
         folder_key = lambda m: m['path'].parent
         medias = sorted(self.found_media_files, key=folder_key)
         # build lists for multiple reference of iterators
@@ -335,9 +342,14 @@ class Scanner:
         name_of_folders = [p.name for p in complete_path_folders]
         logger.debug('complete_path_folders with media files %s'%complete_path_folders)
         logger.debug('name_of_folders with media files %s'%name_of_folders)
-        unique_folder_names = set(name_of_folders)
-        if len(unique_folder_names) != len(name_of_folders):
-            print('There is conflicts for some folder names:')
+        # unique_folder_names = set(name_of_folders)
+        repeated_folders = _list_duplicates(name_of_folders)
+        logger.debug('repeated_folders %s'%repeated_folders)
+        if repeated_folders:
+            print('There are conflicts for some repeated folder names:')
+            for f in [str(p) for p in repeated_folders]:
+                print(' [gold1]%s[/gold1]'%f)
+            print('Here are the complete paths:')
             for f in [str(p) for p in complete_path_folders]:
                 print(' [gold1]%s[/gold1]'%f)
             print('please rename and rerun. Quitting..')

tictacsync/entry.py

@@ -110,7 +110,7 @@ def main():
     # logger.add(sys.stdout, filter="device_scanner")
     # logger.add(sys.stdout, filter="yaltc")
     # logger.add(sys.stdout, filter="timeline")
-    # logger.add(sys.stdout, filter=lambda r: r["function"] == "scan_audio_for_each_ref_rec")
+    # logger.add(sys.stdout, filter=lambda r: r["function"] == "_get_word_envelope")
     # logger.add(sys.stdout, filter=lambda r: r["function"] == "get_timecode")
     # logger.add(sys.stdout, filter=lambda r: r["function"] == "_get_BFSK_symbols_boundaries")
     # logger.add(sys.stdout, filter=lambda r: r["function"] == "_get_BFSK_word_boundaries")

tictacsync/yaltc.py

@@ -63,6 +63,7 @@ SYMBOL_LENGTH = 14.286 # ms, from FSKfreqCalculator.py
 N_SYMBOLS_SAMD21 = 35 # including sync pulse
 ##################
 
+BPF_LOW_FRQ, BPF_HIGH_FRQ = (0.5*F1, 2*F2)
 
 try:
     layouts, _ = (
@@ -190,17 +191,18 @@ class Decoder:
         SN_ratio : float
             signal over noise ratio in dB.
 
-        pulse_level : float
+        pulse_detection_level : float
             level used to detect sync pulse
 
         silent_zone_indices : tuple of ints
             silent zone boundary positions relative to the start
             of self.sound_extract.
+    
+        estimated_pulse_position : int
+            pulse position (samples) relative to the start of self.sound_extract
 
-        pulse_position : dict
-            key 'value' : positions relative to the start of self.sound_extract
-                        of pulse;
-            key 'type' : "estimated" or "detected"
+        detected_pulse_position : int
+            pulse position (samples) relative to the start of self.sound_extract
     
         cached_convolution_fit : dict
             if _fit_triangular_signal_to_convoluted_env() has already been called,
@@ -223,10 +225,10 @@ class Decoder:
     def clear_decoder(self):
         self.sound_data_extract = None
         self.cached_convolution_fit = {'sound_extract_position': None}
-        self.pulse_level = None
+        self.pulse_detection_level = None
         self.silent_zone_indices = None
-        self.pulse_position = {'value': None}
-
+        self.detected_pulse_position = None
+        self.estimated_pulse_position = None
 
     def set_sound_extract_and_sr(self, extract, s_r, where):
         self.sound_extract = extract
@@ -254,21 +256,10 @@ class Decoder:
 
         """
         WINDOW_LENGTH, POLYORDER = (15, 3) # parameters found by experiment, hit and miss
-        abs_hil = np.abs(scipy.signal.hilbert(self.sound_extract))
-        envelope = scipy.signal.savgol_filter(abs_hil,
+        absolute_of_hilbert = np.abs(scipy.signal.hilbert(self.sound_extract))
+        envelope = scipy.signal.savgol_filter(absolute_of_hilbert,
                                               WINDOW_LENGTH, POLYORDER)
-
-        # plt.plot(self.sound_extract)
-        # plt.plot(abs_hil)
-        # plt.plot(envelope)
-        # plt.show()
-
-        # mean = envelope.mean()
-        # if mean: # in case of zero padding
-        #     factor = 0.5/mean # since 50% duty cycle
-        # else:
-        #     factor = 1
-        # return factor*envelope
+        logger.debug('self.sound_extract envelope length %i samples'%len(envelope))
         return envelope
 
     def _get_signal_level(self):
@@ -277,30 +268,30 @@ class Decoder:
 
     def _get_pulse_position(self):
         # relative to extract beginning
-        # return precise value
-        if self.pulse_position['value'] is not None:
-            return self.pulse_position['value']
+        if self.detected_pulse_position:
+            logger.debug('returning detected value')
+            return self.detected_pulse_position
+        if self.estimated_pulse_position:
+            return self.estimated_pulse_position
         _, silence_center_x = self._fit_triangular_signal_to_convoluted_env()
         # symbol_width_samples = 1e-3*SYMBOL_LENGTH
-        pulse_relative_pos = int(0.5*(0.5 - 1e-3*SYMBOL_LENGTH)*self.samplerate)
-        approx_pulse_x = silence_center_x + pulse_relative_pos
-        self.pulse_position = {}
-        self.pulse_position['value'] = approx_pulse_x
-        self.pulse_position['type'] = 'estimated'
-        return self.pulse_position['value']
-
-    def _get_pulse_level(self):
+        self.estimated_pulse_position = silence_center_x + int(0.5*(
+            0.5 - 1e-3*SYMBOL_LENGTH)*self.samplerate)
+        logger.debug('returning estimated value from silence mid position')
+        return self.estimated_pulse_position
+
+    def _get_pulse_detection_level(self):
         # return the geometric mean between silence and BFSK levels
-        if self.pulse_level is None:
+        if self.pulse_detection_level is None:
             silence_floor = self._get_silence_floor()
             # lower_BFSK_level = silence_floor
-            pulse_position = self._get_pulse_position()
-            lower_BFSK_level = self._get_minimal_bfsk(pulse_position)
+            # pulse_position = self._get_pulse_position()
+            lower_BFSK_level = self._get_minimal_bfsk()
             value = math.sqrt(silence_floor * lower_BFSK_level)
-            self.pulse_level = value
+            self.pulse_detection_level = value
             return value
         else:
-            return self.pulse_level
+            return self.pulse_detection_level
 
     def _get_square_convolution(self):
         """
@@ -333,37 +324,50 @@ class Decoder:
         x = range(start, len(convol) + start)
         return [*x], convol
 
-    def _get_word_envelope(self, pulse_position):
+    def _get_word_envelope(self):
         """
         Chop the signal envelope keeping the word region and smooth it over the
         longest BFSK period
         """
-        max_period = int(self.samplerate*max(1/F1,1/F2))
-        logger.debug('max BFSK period %i samples'%max_period)
-        period_window = np.ones(max_period,dtype=int)/max_period
+        SR = self.samplerate
         envelope = self._get_envelope()
-        symbol_width_samples = 1e-3*SYMBOL_LENGTH*self.samplerate
+        pulse_position = self._get_pulse_position()
+        samples_to_end = len(self.sound_extract) - pulse_position
+        is_too_near_the_end = samples_to_end/SR < 0.5
+        logger.debug('pulse_position is_too_near_the_end %s'%
+            is_too_near_the_end)
+        if is_too_near_the_end:
+            pulse_position -= SR # one second sooner
+        symbol_width_samples = 1e-3*SYMBOL_LENGTH*SR
         word_start = int(pulse_position + 3*symbol_width_samples)
-        word_end = int(pulse_position + 0.5*self.samplerate)
-        word_end -= 2*symbol_width_samples # slide to the left a little
-        logger.debug('word start, end: %i %i'%(word_start, word_end))
-        w_envelope = envelope[word_start:int(word_end)]
-        # plt.plot(w_envelope)
-        # plt.show()
-        return w_envelope
-        # return np.convolve(w_envelope, period_window, mode='same')
+        word_end = int(pulse_position + 0.5*SR)
+        word_end -= int(2*symbol_width_samples) # slide to the left a little
+        logger.debug('word start, end: %i %i (in file)'%(
+            word_start + self.sound_extract_position,
+            word_end + self.sound_extract_position))
+        w_envelope = envelope[word_start : word_end]
+        word_envelope_truncated = word_end-word_start != len(w_envelope)
+        logger.debug('w_envelope is sliced out of bounds: %s'%(
+            str(word_envelope_truncated)))
+        logger.debug('word envelope length %i samples %f secs'%(
+            len(w_envelope), len(w_envelope)/SR))
+        max_period = int(self.samplerate*max(1/F1,1/F2))
+        logger.debug('max BFSK period %i in samples'%max_period)
+        period_window = np.ones(max_period,dtype=int)/max_period
+        # smooth over longest BFSK period
+        return np.convolve(w_envelope, period_window, mode='same')
 
-    def _get_minimal_bfsk(self, pulse_position):
+    def _get_minimal_bfsk(self):
         """
         because of non-flat frequency response, bfsk bits dont have the same
         amplitude. This returns the least of both by detecting a bimodal
         gaussian distribution
 
         """
-        # w_envelope = self._get_word_envelope(pulse_position)
+        # w_envelope = self._get_word_envelope()
         # word_start = int(min_position + shift + 0.3*self.samplerate)
         # word = w_envelope[word_start :  int(word_start + 0.4*self.samplerate)]
-        word = self._get_word_envelope(pulse_position)
+        word = self._get_word_envelope()
         # plt.plot(word)
         # plt.show()
         n = len(word)
@@ -407,12 +411,11 @@ class Decoder:
             logger.debug('yes, fit values cached:')
             v1 = self.cached_convolution_fit['chi_square']
             v2 = self.cached_convolution_fit['minimum position']
-            logger.debug('chi_square: %s minimum position: %s'%(v1, v2))
+            v2_file = v2 + self.sound_extract_position
+            logger.debug('cached chi_sq: %s minimum position in file: %s'%(v1, v2_file))
             return (v1, v2)
                 # cached!
         x_shifted, convolution = self._get_square_convolution()
-
-        shift = x_shifted[0] # convolution is shorter than sound envelope
         # see numpy.convolve(..., mode='valid')
         x = np.arange(len(convolution))
         trig_params = lmfit.Parameters()
@@ -441,12 +444,13 @@ class Decoder:
                             args=(x,), kws={'signal_data': convolution}
                             )
         chi_square = fit_trig.chisqr
-        min_position = int(fit_trig.params['min_position'].value)
-        logger.debug('chi_square %.1f minimum convolution position %i'%
-                     (chi_square, min_position + shift))
+        shift = x_shifted[0] # convolution is shorter than sound envelope
+        min_position = int(fit_trig.params['min_position'].value) + shift
+        logger.debug('chi_square %.1f minimum convolution position %i in file'%
+                     (chi_square, min_position + self.sound_extract_position))
         self.cached_convolution_fit['sound_extract_position'] = self.sound_extract_position
         self.cached_convolution_fit['chi_square'] = chi_square
-        self.cached_convolution_fit['minimum position'] = min_position + shift
+        self.cached_convolution_fit['minimum position'] = min_position
 
         return chi_square, min_position + shift
 
@@ -468,9 +472,7 @@ class Decoder:
     def _get_silent_zone_indices(self):
         """
         Returns silent zone boundary positions relative to the start
-        of self.sound_extract. Adjustment are made so a complete
-        0.5 second signal is at the left of the silent zone for word
-        decoding.
+        of self.sound_extract.
 
         Returns
         -------
@@ -480,7 +482,7 @@ class Decoder:
             right indice.
 
         """
-        if self.silent_zone_indices is not None:
+        if self.silent_zone_indices:
             return self.silent_zone_indices
         _, silence_center_position = self._fit_triangular_signal_to_convoluted_env()
         srate = self.samplerate
@@ -488,9 +490,10 @@ class Decoder:
         left_window_boundary = silence_center_position - half_window
         right_window_boundary = silence_center_position + half_window
         # margin = 0.75 * srate
-        logger.debug('silent zone, left: %i, right %i, center %i'%
-            (left_window_boundary, right_window_boundary,
-             silence_center_position))
+        values = np.array([left_window_boundary, right_window_boundary,
+                    silence_center_position])
+        values += self.sound_extract_position # samples pos in file
+        logger.debug('silent zone, left: %i, right %i, center %i'%tuple(values))
         self.silent_zone_indices = (left_window_boundary, right_window_boundary)
         return self.silent_zone_indices
  
@@ -520,7 +523,7 @@ class Decoder:
         x_convolution, convolution = self._get_square_convolution()
         scaled_convo = self._get_signal_level()*convolution
         # since 0 < convolution < 1
-        trig_level = self._get_pulse_level()
+        trig_level = self._get_pulse_detection_level()
         sound_extract_position = self.sound_extract_position
         def x2f(nx):
             return nx + sound_extract_position
@@ -545,7 +548,7 @@ class Decoder:
             approx_pulse_x, 0.1, 0.9, 
             transform=xt, linewidth=1, colors='yellow'
             )
-        bfsk_min = self._get_minimal_bfsk(approx_pulse_x)
+        bfsk_min = self._get_minimal_bfsk()
         ax.hlines(
             bfsk_min, 0, 1, 
             transform=yt, linewidth=1, colors='red'
@@ -598,15 +601,18 @@ class Decoder:
 
     def _detect_sync_pulse_position(self):
         """
-        Determines noise level during silence period and use it to detect
-        the sync pulse position. Computes SN_ratio and stores it.
+        Determines noise level during silence period and use it to detect the
+        sync pulse position. Computes SN_ratio and stores it. Start searching
+        around end of silent zone. Adjustment are made so a complete 0.5
+        second signal is at the right of the starting search position so a
+        complete 0.5 s word is available for decoding.
+
         Returns the pulse position relative to the extract beginning.
         """
-        start_silent_zone, end_silent_zone = self._get_silent_zone_indices()
-        pulse_level = self._get_pulse_level()
+        pulse_detection_level = self._get_pulse_detection_level()
         abs_signal = abs(self.sound_extract)
         mean_during_word = 2*abs_signal.mean()
-        self.SN_ratio = 20*math.log10(mean_during_word/pulse_level)
+        self.SN_ratio = 20*math.log10(mean_during_word/pulse_detection_level)
         logger.debug('SN ratio: %f dB'%(self.SN_ratio))
         search_pulse_start_point = self._get_pulse_position()
         search_pulse_start_point -= 3*SYMBOL_LENGTH*1e-3*self.samplerate
@@ -624,17 +630,20 @@ class Decoder:
         logger.debug('search_pulse_start_point: %i in extract'%
                 search_pulse_start_point)
         abs_signal_after_silence = abs_signal[search_pulse_start_point:]
+        # here the real searching with numpy.argmax()
         first_point = \
-            np.argmax(abs_signal_after_silence > pulse_level)
+                    np.argmax(abs_signal_after_silence > pulse_detection_level)
         first_point += search_pulse_start_point
         logger.debug('found sync pulse at %i in extract'%first_point)
+        self.detected_pulse_position = first_point
         return first_point
 
-    def _get_word_width_parameters(self, pulse_position):
+    def _get_word_width_parameters(self):
         abs_signal = abs(self.sound_extract)
+        pulse_position = self._get_pulse_position()
         # half_amplitude = abs_signal.mean() # since 50% duty cycle OLD
         # params = {'word_width_threshold':WORDWIDTHFACTOR*half_amplitude} OLD
-        bfsk_min = self._get_minimal_bfsk(pulse_position)
+        bfsk_min = self._get_minimal_bfsk()
         params = {'word_width_threshold': 0.8*bfsk_min}
         sr = self.samplerate
         presumed_symbol_length = SYMBOL_LENGTH*1e-3*sr
@@ -649,10 +658,11 @@ class Decoder:
         params['presumed_symbol_length'] = presumed_symbol_length
         return params
 
-    def _get_BFSK_word_boundaries(self, pulse_position):
+    def _get_BFSK_word_boundaries(self):
         n_bits = N_SYMBOLS_SAMD21 - 1
         sr = self.samplerate
-        wwp = self._get_word_width_parameters(pulse_position)
+        wwp = self._get_word_width_parameters()
+        pulse_position = self._get_pulse_position()
         # search_start_position = wwp['search_start_position']
         search_end_position = wwp['search_end_position']
         word_width_threshold = wwp['word_width_threshold']
@@ -689,10 +699,11 @@ class Decoder:
         logger.debug(' relative discrepancy %.4f%%'%(abs(100*relative_error)))
         return status, left_boundary, right_boundary
 
-    def _get_BFSK_symbols_boundaries(self, pulse_position):
+    def _get_BFSK_symbols_boundaries(self):
         # returns indices of start of each slice and boundaries
+        pulse_position = self._get_pulse_position()
         boundaries_OK, left_boundary, right_boundary = \
-                self._get_BFSK_word_boundaries(pulse_position)
+                self._get_BFSK_word_boundaries()
         if left_boundary is None:
             return None, None, None
         symbol_width_samples = \
@@ -741,7 +752,8 @@ class Decoder:
         logger.debug('slicing intervals, word_intervals = %s'%
                                                 word_intervals)
         # skip sample after pulse, start at BFSK word
-        slices = [self.sound_extract[slice(*pair)]
+        filtered_sound_extract = self._band_pass_filter(self.sound_extract)
+        slices = [filtered_sound_extract[slice(*pair)]
                             for pair in word_intervals]
         np.set_printoptions(threshold=5)
         # logger.debug('data slices: \n%s'%pprint.pformat(slices))
@@ -756,13 +768,17 @@ class Decoder:
         freq_in_hertz = abs(freq * self.samplerate)
         return int(round(freq_in_hertz))
 
+    # def _get_bit_from_freq(self, freq):
+    #     if math.isclose(freq, F1, abs_tol=FSK_TOLERANCE):
+    #         return '0'
+    #     if math.isclose(freq, F2, abs_tol=FSK_TOLERANCE):
+    #         return '1'
+    #     else:
+    #         return None
+
     def _get_bit_from_freq(self, freq):
-        if math.isclose(freq, F1, abs_tol=FSK_TOLERANCE):
-            return '0'
-        if math.isclose(freq, F2, abs_tol=FSK_TOLERANCE):
-            return '1'
-        else:
-            return None
+        mid_FSK = 0.5*(F1 + F2)
+        return '1' if freq > mid_FSK else '0'
 
     def _get_int_from_binary_str(self, string_of_01s):
         return int(''.join(reversed(string_of_01s)),2)
@@ -791,15 +807,14 @@ class Decoder:
         # save figure in filename if set, otherwise
         # start an interactive plot, title is for matplotlib
         signal = self.sound_extract
+        # signal = self._band_pass_filter(signal)
         start = self.sound_extract_position
         x_signal_in_file = range(
                                 start,
                                 start + len(signal)
                                 )
+        wwp = self._get_word_width_parameters()
         start_silent_zone, end_silent_zone = self._get_silent_zone_indices()
-        # sync_pulse = self._detect_sync_pulse_position()
-        wwp = self._get_word_width_parameters(sync_pulse)
-        # search_start_position = wwp['search_start_position'] + start
         search_end_position = wwp['search_end_position'] + start
         fig, ax = plt.subplots()
         plt.title(title)
@@ -836,9 +851,8 @@ class Decoder:
             [end_silent_zone + start], [0],
             marker='<', markersize='10',
             linewidth=0.3, color='green', alpha=0.3)
-        # symbols_indices = self._get_BFSK_symbols_boundaries(sync_pulse)
         boundaries_OK, word_lft, word_rght = \
-            self._get_BFSK_word_boundaries(sync_pulse)
+            self._get_BFSK_word_boundaries()
         ax.vlines(
             word_lft + start, 0, 1,
             transform=ax.get_xaxis_transform(),
@@ -869,18 +883,27 @@ class Decoder:
                 dpi=height/fig.get_size_inches()[1])
             plt.close()
 
+    def _band_pass_filter(self, data):
+        # return filtered data
+        def _bandpass(data: np.ndarray, edges: list[float], sample_rate: float, poles: int = 5):
+            sos = scipy.signal.butter(poles, edges, 'bandpass', fs=sample_rate, output='sos')
+            filtered_data = scipy.signal.sosfiltfilt(sos, data)
+            return filtered_data
+        sample_rate = self.samplerate
+        times = np.arange(len(data))/sample_rate
+        return _bandpass(data, [BPF_LOW_FRQ, BPF_HIGH_FRQ], sample_rate)
+
     def get_time_in_sound_extract(self, plots):
         if self.sound_extract is None:
             return None
         if plots:
             self.make_silence_analysis_plot()
-        start_silent_zone, end_silent_zone = self._get_silent_zone_indices()
         pulse_position = self._detect_sync_pulse_position()
         pulse_pos_in_file = pulse_position + self.sound_extract_position
         pulse_position_sec = pulse_pos_in_file/self.samplerate
         logger.debug('found sync pulse at sample %i in file'%pulse_pos_in_file)
         symbols_indices, word_lft, word_rght = \
-            self._get_BFSK_symbols_boundaries(pulse_position)
+            self._get_BFSK_symbols_boundaries()
         if plots:
             title = 'Bit slicing at %s, %.2f s'%(pulse_pos_in_file,
                     pulse_position_sec)
@@ -891,6 +914,10 @@ class Decoder:
         if symbols_indices is None:
             return None
         sliced_data = self._slice_sound_extract(symbols_indices)
+        # sliced_data = [self._band_pass_filter(data_slice)
+        #                     for data_slice
+        #                     in sliced_data
+        #                     ]
         frequencies = [self._get_main_frequency(data_slice)
                             for data_slice
                             in sliced_data
@@ -902,12 +929,12 @@ class Decoder:
         length_ratio = eff_symbol_length / SYMBOL_LENGTH
         logger.debug('symbol length_ratio (eff/supposed) %f'%length_ratio)
         corrected_freq = np.array(frequencies)*length_ratio
-        logger.debug('corrrected freq (using symbol length) = %s'%corrected_freq)
+        logger.debug('corrected freq (using symbol length) = %s'%corrected_freq)
         bits = [self._get_bit_from_freq(f) for f in corrected_freq]
         for i, bit in enumerate(bits):
             if bit == None:
                 logger.warning('cant decode frequency %i for bit at %i-%i'%(
-                                frequencies[i],
+                                corrected_freq[i],
                                 symbols_indices[i],
                                 symbols_indices[i+1]))
         if None in bits:
@@ -923,8 +950,6 @@ class Decoder:
         time_values['clock source'] = 'GPS' \
             if time_values['clock source'] == 1 else 'RTC'
         if self._demod_values_are_OK(time_values):
-            self.pulse_position['value'] = pulse_position
-            self.pulse_position['type'] = 'detected'
             return time_values
         else:
             return None
@@ -940,10 +965,10 @@ class Recording:
         media_without_YaLTC : pathlib.path
             path of video+sound file stripped of YaLTC channel
 
-        device: str
+        device : str
             identifies the device used for the recording, set in __init__()
 
-        new_rec_name: str
+        new_rec_name : str
             built using the device name, ex: "CAM_A001"
             set by Timeline._rename_all_recs()
 
@@ -958,25 +983,25 @@ class Recording:
         decoder : yaltc.decoder
             associated decoder object, if file is audiovideo
 
-        true_samplerate: float
+        true_samplerate : float
             true sample rate using GPS time
 
-        start_time: datetime or str
+        start_time : datetime or str
             time and date of the first sample in the file, cached
             after a call to get_start_time(). Value on initialization
             is None.
 
-        sync_position: int
+        sync_position : int
             position of first detected syn pulse
 
-        is_reference: bool (True for ref rec only)
+        is_reference : bool (True for ref rec only)
             in multi recorders set-ups, user decides if a sound-only recording
             is the time reference for all other audio recordings. By
             default any video recording is the time reference for other audio,
             so this attribute is only relevant to sound recordings and is
             implicitly True for each video recordings (but not set)
 
-        device_relative_speed: float
+        device_relative_speed : float
             the ratio of the recording device clock speed relative to the
             reference_rec clock device, in order to correct clock drift with
             pysox tempo transform. If value < 1.0 then the recording is slower
@@ -985,7 +1010,7 @@ class Recording:
             sound). A mean is calculated for all recordings of the same device
             in Montage._get_concatenated_audiofile_for()
 
-        time_position: float
+        time_position : float
             The time (in seconds) at which the recording starts relative to the
             reference recording. Updated by each Montage instance so the value
             can change depending on the reference recording (a video or main
@@ -1000,7 +1025,7 @@ class Recording:
             contains the path of audio only of self.final_synced_file. Absolute
             path to tempfile.
 
-        in_cam_audio_sync_error: int
+        in_cam_audio_sync_error : int
             in cam audio sync error, read in the camera folder. Negative value
             for lagging video (audio leads) positive value for lagging audio
             (video leads)

{tictacsync-0.1a10.dist-info → tictacsync-0.1a11.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: tictacsync
-Version: 0.1a10
+Version: 0.1a11
 Summary: command for syncing audio video recordings
 Home-page: https://sr.ht/~proflutz/TicTacSync/
 Author: Raymond Lutz

tictacsync-0.1a11.dist-info/RECORD

@@ -0,0 +1,11 @@
+tictacsync/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tictacsync/device_scanner.py,sha256=ybMGhSPbrfFvSWEjv0zYtwDSClVQRfGYQVJcakpuU54,18522
+tictacsync/entry.py,sha256=kboDNw_VA5-bOPMiJS6JMftqlTW0FsHxrsHMfW5ckp0,8689
+tictacsync/timeline.py,sha256=q0jhHqhj2cdjL4UIWv6_dAC7VfjQUb69Tu4VP5kULzg,34829
+tictacsync/yaltc.py,sha256=qWLhV2PP1KWoLmSVlSGGYCiCzImm6bnbPTVYilYrzzQ,69123
+tictacsync-0.1a11.dist-info/LICENSE,sha256=ZAOPXLh1zlQAnhHUd7oLslKM01YZ5UiAu3STYjwIxck,1068
+tictacsync-0.1a11.dist-info/METADATA,sha256=RvufymvGNYowOv8iwEREhXTHXT96VaqtyRn1iFui4Y0,4256
+tictacsync-0.1a11.dist-info/WHEEL,sha256=pqI-DBMA-Z6OTNov1nVxs7mwm6Yj2kHZGNp_6krVn1E,92
+tictacsync-0.1a11.dist-info/entry_points.txt,sha256=7Ih9Xas4RWMDqt2adwXpt7x9j2YtXwj_jl-jNhkIArg,54
+tictacsync-0.1a11.dist-info/top_level.txt,sha256=eaCWG-BsYTRR-gLTJbK4RfcaXajr0gjQ6wG97MkGRrg,11
+tictacsync-0.1a11.dist-info/RECORD,,

tictacsync-0.1a10.dist-info/RECORD

@@ -1,11 +0,0 @@
-tictacsync/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-tictacsync/device_scanner.py,sha256=8xz2Ztnnml2y5K6-XkobvcbfoOcVo9eXSQKqcI6ysHU,17889
-tictacsync/entry.py,sha256=nLSxP0WxH02-3s1asqV_N81mgHvvCoeE5cwNAbPChw8,8698
-tictacsync/timeline.py,sha256=q0jhHqhj2cdjL4UIWv6_dAC7VfjQUb69Tu4VP5kULzg,34829
-tictacsync/yaltc.py,sha256=kq6qgP5R4zTcgUAM2AMXZEu1er-arWQJ11gNELmVF-Q,67508
-tictacsync-0.1a10.dist-info/LICENSE,sha256=ZAOPXLh1zlQAnhHUd7oLslKM01YZ5UiAu3STYjwIxck,1068
-tictacsync-0.1a10.dist-info/METADATA,sha256=KTkUJlrf3VNkUdt0zMMzXVASEFz4nB5ST5Q2m12x6_k,4256
-tictacsync-0.1a10.dist-info/WHEEL,sha256=pqI-DBMA-Z6OTNov1nVxs7mwm6Yj2kHZGNp_6krVn1E,92
-tictacsync-0.1a10.dist-info/entry_points.txt,sha256=7Ih9Xas4RWMDqt2adwXpt7x9j2YtXwj_jl-jNhkIArg,54
-tictacsync-0.1a10.dist-info/top_level.txt,sha256=eaCWG-BsYTRR-gLTJbK4RfcaXajr0gjQ6wG97MkGRrg,11
-tictacsync-0.1a10.dist-info/RECORD,,