tictacsync 0.1a13__py3-none-any.whl → 0.1a15__py3-none-any.whl

tictacsync/device_scanner.py

@@ -17,6 +17,8 @@ AMR APE AU AWB DSS DVF FLAC GSM IKLAX IVS M4A M4B M4P MMF MP3 MPC MSV NMF
 OGG OGA MOGG OPUS RA RM RAW RF64 SLN TTA VOC VOX WAV WMA WV WEBM 8SVX CDA MOV AVI BWF""".split()
 
 import ffmpeg
+from os import listdir
+from os.path import isfile, join, isdir
 from collections import namedtuple
 from pathlib import Path
 from pprint import pformat 
@@ -121,24 +123,28 @@ def get_device_ffprobe_UID(file):
 class Scanner:
     """
     Class that encapsulates scanning of the directory given as CLI argument.
-    Depending on the IO structure choosen (loose|foldercam), enforce some directory
+    Depending on the IO structure choosen (loose|folder_is_device), enforce some directory
     structure (or not). Build a list of media files found and a try to 
     indentify uniquely the device used to record each media file.
 
     Attributes:
 
-        IO_structure: string
+        input_structure: string
 
             Any of
-                'loose' [DEFAULT]
-                    all files audio + video in the same folder
-                'foldercam'
+                'loose'
+                    all files audio + video are in top folder
+                'folder_is_device'
                     eg for multicam on Davinci Resolve
 
         top_directory : string
 
             String of path of where to start searching for media files.
 
+        top_dir_has_multicam : bool
+
+            If top dir is folder structures AND more than on cam
+
         devices_names : dict of str
 
             more evocative names for each device, keys are same as
@@ -148,14 +154,13 @@ class Scanner:
                 {
                 'path' : as is ,
                 'sample length' : as is
-                'dev' : Device named tuple
+                'dev' : Device namedtuple
                 }
     """
 
     def __init__(
                     self,
                     top_directory,
-                    IOstruct,
                     stay_silent=False,
                 ):
         """
@@ -164,9 +169,9 @@ class Scanner:
         """
         self.top_directory = top_directory
         self.found_media_files = []
-        self.IOstruct = IOstruct
         self.stay_silent = stay_silent
 
+
     def get_devices_number(self):
         # how many devices have been found
         return len(set([m['dev'].UID for m in self.found_media_files]))
@@ -185,12 +190,33 @@ class Scanner:
 
         Populates Scanner.found_media_files, a list of dict as
                 {
-                'path' : # as is,
-                'sample length' : # in samples
-                'dev UID' : dev_UID or None
+                'path' : as is ,
+                'sample length' : as is
+                'dev' : Device namedtuple
                 }
 
+        Sets input_structure = 'loose'|'folder_is_device'
+
         """
+        visible = [f for f in listdir(self.top_directory) if f[0] != '.']
+        logger.debug('visible: %s'%visible)
+        are_dir = all([isdir(join(self.top_directory, f)) for f in visible])
+        are_files = all([isfile(join(self.top_directory, f)) for f in visible])
+        # onlyfiles = [f for f in listdir(self.top_directory) if isfile()]
+
+        logger.debug('dir: %s'%[isdir(join(self.top_directory, f)) for f in visible])
+        if are_dir:
+            print('\nAssuming those are device folders: ',end='')
+            [print(f, end=', ') for f in visible[:-1]]
+            print('%s.\n'%visible[-1])
+            self.input_structure = 'folder_is_device'
+        else: # are_files
+            self.input_structure = 'loose'
+        if not are_dir and not are_files:
+            print('\nInput structure mixed up, files AND folders at top level')
+            print('  %s, quitting.\n'%self.top_directory)
+            quit()
+        # quit()
         files = Path(self.top_directory).rglob('*.*')
         paths = [
             p
@@ -202,15 +228,17 @@ class Scanner:
             new_media = media_dict_from_path(p) # dev UID set here
             self.found_media_files.append(new_media)
         logger.debug('Scanner.found_media_files = %s'%self.found_media_files)
-        if self.IOstruct == 'foldercam':
-                self._enforce_folder_structure_alpha()
-                self._use_folder_as_device_ID()
+        if self.input_structure == 'folder_is_device':
+                self._enforce_folder_is_device()
+                self._use_folder_as_device_name()
+        else:
+            self.top_dir_has_multicam = False
         pprint_found_media_files = pformat(self.found_media_files)
         logger.debug('scanner.found_media_files = %s'%pprint_found_media_files)
 
-    def _use_folder_as_device_ID(self):
+    def _use_folder_as_device_name(self):
         """
-        For each media in self.found_media_files replace existing dev_UID by
+        For each media in self.found_media_files replace existing Device.name by
         folder name.
 
         Returns nothing
@@ -229,7 +257,7 @@ class Scanner:
             #     quit()
         logger.debug(self.found_media_files)
 
-    def _enforce_folder_structure_alpha(self):
+    def _enforce_folder_is_device(self):
         """
 
         Checks for files in self.found_media_files for structure as following.
@@ -259,6 +287,7 @@ class Scanner:
         # build lists for multiple reference of iterators
         media_grouped_by_folder = [ (k, list(iterator)) for k, iterator
                         in groupby(medias, folder_key)]
+        logger.debug('media_grouped_by_folder %s'%media_grouped_by_folder)
         complete_path_folders = [e[0] for e in media_grouped_by_folder]
         name_of_folders = [p.name for p in complete_path_folders]
         logger.debug('complete_path_folders with media files %s'%complete_path_folders)
@@ -276,11 +305,15 @@ class Scanner:
             print('please rename and rerun. Quitting..')
             quit()
         # print(media_grouped_by_folder)
+        n_CAM_folder = 0
         for folder, list_of_medias_in_folder in media_grouped_by_folder:
             # list_of_medias_in_folder = list(media_files_same_folder_iterator)
             # check all medias are either video or audio recordings in folder
             # if not, warn user and quit.
             dev_types = set([m['dev'].type for m in list_of_medias_in_folder])
+            logger.debug('dev_types %s'%dev_types)
+            if dev_types == {'CAM'}:
+                n_CAM_folder += 1
             if len(dev_types) != 1:
                 print('\nProblem while scanning for media files. In [gold1]%s[/gold1]:'%folder)
                 print('There is a mix of video and audio files:')
@@ -295,7 +328,7 @@ class Scanner:
             logger.debug('devices in folder %s:'%folder)
             logger.debug('  media with unknown devices %s'%unidentified)
             logger.debug('  media with UIDed devices %s'%UIDed)
-            if False and len(unidentified) != 0 and len(UIDed) != 0:
+            if len(unidentified) != 0 and len(UIDed) != 0:
                 print('\nProblem while grouping files in [gold1]%s[/gold1]:'%folder)
                 print('There is a mix of unidentifiable and identified devices.')
                 print('Is this file:')
@@ -328,7 +361,10 @@ class Scanner:
             # if we are here, the check is done: either 
             #   all files in folder are from unidentified device or
             #   all files in folder are from the same identified device
-            return
+        logger.debug('n_CAM_folder %i'%n_CAM_folder)
+        self.top_dir_has_multicam = n_CAM_folder > 1
+        logger.debug('top_dir_has_multicam: %s'%self.top_dir_has_multicam)
+        return
 
 
 

tictacsync/entry.py

@@ -118,25 +118,28 @@ def main():
     parser.add_argument('-p', action='store_true', default=False,
                     dest='plotting',
                     help='Make plots')
+    parser.add_argument('--isos', action='store_true', default=False,
+                    dest='write_ISOs',
+                    help='Write ISO sound files')
     parser.add_argument('--nosync', action='store_true',
                     dest='nosync',
                     help='just scan and decode')
     parser.add_argument('--terse', action='store_true',
                     dest='terse',
                     help='terse output')
-    parser.add_argument('--io', dest='output_structure', type=str, default='loose',
-                    help='should be one of: loose [DEFAULT], foldercam')
+    # parser.add_argument('--io', dest='output_structure', type=str, default='loose',
+    #                 help='should be one of: loose [DEFAULT], foldercam')
     args = parser.parse_args()
-    if not args.output_structure in 'loose foldercam reconf'.split():
-        print('Unknown --io option value "%s", should be one of: loose [DEFAULT] or foldercam'%args.output_structure)
-        quit()
+    # if not args.output_structure in 'loose foldercam reconf'.split():
+    #     print('Unknown --io option value "%s", should be one of: loose [DEFAULT] or foldercam'%args.output_structure)
+    #     quit()
     if args.verbose_output:
         logger.add(sys.stderr, level="DEBUG")
     # logger.add(sys.stdout, filter="__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"] == "_parse_track_values")
+    # logger.add(sys.stdout, filter=lambda r: r["function"] == "_enforce_folder_is_device")
     # logger.add(sys.stdout, filter=lambda r: r["function"] == "build_audio_and_write_video")
     # logger.add(sys.stdout, filter=lambda r: r["function"] == "_get_BFSK_word_boundaries")
     top_dir = args.directory[0]
@@ -147,8 +150,7 @@ def main():
         print('%s is not a directory or doesnt exist.'%top_dir)
         quit()
     multi2polywav.poly_all(top_dir)
-    scanner = device_scanner.Scanner(top_dir, args.output_structure,
-                stay_silent=args.terse)
+    scanner = device_scanner.Scanner(top_dir, stay_silent=args.terse)
     # (Path(top_dir)/Path('tictacsynced')).mkdir(exist_ok=True)
     # scanner.cluster_media_files_by_name()
     scanner.scan_media_and_build_devices_UID(recursive=False)
@@ -208,6 +210,7 @@ def main():
         console.print(table)
         print('\n')
     n_devices = scanner.get_devices_number()
+    OUT_struct_for_mcam = scanner.top_dir_has_multicam
     # if n_devices > 2:
     #     print('\nMerging for more than 2 devices is not implemented yet, quitting...')
     #     quit()
@@ -215,7 +218,7 @@ def main():
         if not args.terse:
             print('\nNothing to sync, exiting.\n')
         quit()
-    matcher = timeline.Matcher(recordings_with_time, args.output_structure)
+    matcher = timeline.Matcher(recordings_with_time)
     matcher.scan_audio_for_each_ref_rec()
     if not matcher.video_mergers:
         if not args.terse:
@@ -223,23 +226,25 @@ def main():
         quit()
     if args.verbose_output or args.terse: # verbose, so no progress bars
         for stitcher in matcher.video_mergers:
-            stitcher.build_audio_and_write_video(top_dir, args.output_structure)
+            stitcher.build_audio_and_write_video(top_dir, OUT_struct_for_mcam,
+                                                    args.write_ISOs)
     else: 
         for stitcher in track(matcher.video_mergers,
             description="4/4         Merging sound to videos:"):
-            stitcher.build_audio_and_write_video(top_dir, args.output_structure)
+            stitcher.build_audio_and_write_video(top_dir, OUT_struct_for_mcam,    
+                                                    args.write_ISOs)
     if not args.terse:
         print("\n")
-    if args.output_structure == 'foldercam':
-        print('output written in [gold1]%s[/gold1] folder in [gold1]%s[/gold1]\n'%(
+    # if args.output_structure == 'foldercam':
+    print('output written in [gold1]%s[/gold1] folder in [gold1]%s[/gold1]\n'%(
             'SyncedMedia',top_dir))
-    if args.output_structure == 'loose':
-        for stitcher in matcher.video_mergers:
-            print('[gold1]%s[/gold1]'%stitcher.ref_recording.AVpath.name, end='')
-            for audio in stitcher.get_matched_audio_recs():
-                print(' + [gold1]%s[/gold1]'%audio.AVpath.name, end='')
-            new_file = stitcher.ref_recording.final_synced_file.parts
-            print(' became [gold1]%s[/gold1]'%stitcher.ref_recording.final_synced_file.name)
+    # if args.output_structure == 'loose':
+    for stitcher in matcher.video_mergers:
+        print('[gold1]%s[/gold1]'%stitcher.ref_recording.AVpath.name, end='')
+        for audio in stitcher.get_matched_audio_recs():
+            print(' + [gold1]%s[/gold1]'%audio.AVpath.name, end='')
+        new_file = stitcher.ref_recording.final_synced_file.parts
+        print(' became [gold1]%s[/gold1]'%stitcher.ref_recording.final_synced_file.name)
         # matcher._build_otio_tracks_for_cam()
     matcher.shrink_gaps_between_takes()
     

tictacsync/timeline.py

@@ -464,7 +464,7 @@ class AudioStitcherVideoMerger:
                 return {'error msg': 'more than one "mix" token'}
             output_dict['mix'] = [mono_mix_tags[0][1]]
         else:
-            output_dict['mix'] = None
+            output_dict['mix'] = []
         [tracks_lines.remove(e) for e in mono_mix_tags]
         logger.debug('mono mix done, will continue with %s'%tracks_lines)
         # fourth, look for 'ttc'
@@ -484,18 +484,22 @@ class AudioStitcherVideoMerger:
             output_dict['0'] = zeroed
             [tracks_lines.remove(('0',i)) for i in zeroed]
         else:
-            output_dict['0'] = None
+            output_dict['0'] = []
         # sixth, check for 'others'
         logger.debug('0s done, will continue with %s'%tracks_lines)
         if tracks_lines:
             output_dict['others'] = tracks_lines
         else:
-            output_dict['others'] = None
+            output_dict['others'] = []
         return output_dict
 
-    def build_audio_and_write_video(self, top_dir, IO_structure):
+    def build_audio_and_write_video(self, top_dir,
+                                    OUT_struct_for_mcam,
+                                    write_ISOs):
         """
-        IO_structure is either: loose | foldercam
+        OUT_struct_for_mcam: bool flag
+
+        write_ISOs: bool flag
 
         For each audio devices found overlapping self.ref_recording: pad, trim
         or stretch audio files calling _get_concatenated_audiofile_for(), and
@@ -509,15 +513,14 @@ class AudioStitcherVideoMerger:
         """
         logger.debug('device for rec %s: %s'%(self.ref_recording,
             self.ref_recording.device))
-        match IO_structure:
-            case 'foldercam':
-                D1, D2 = CAMDIR.split('/')
-                device_name = self.ref_recording.device.name
-                synced_clip_dir = Path(top_dir)/D1/D2/device_name
-                os.makedirs(synced_clip_dir, exist_ok=True)
-                logger.debug('created %s'%synced_clip_dir)
-            case 'loose':
-                synced_clip_dir = Path(top_dir)
+        D1, D2 = CAMDIR.split('/')
+        if OUT_struct_for_mcam:
+            device_name = self.ref_recording.device.name
+            synced_clip_dir = Path(top_dir)/D1/D2/device_name
+            logger.debug('created %s'%synced_clip_dir)
+        else:
+            synced_clip_dir = Path(top_dir)/D1
+        os.makedirs(synced_clip_dir, exist_ok=True)
         synced_clip_file = synced_clip_dir/Path(self.ref_recording.new_rec_name).name
         logger.debug('editing files for %s'%synced_clip_file)
         # looping over devices:
@@ -540,17 +543,34 @@ class AudioStitcherVideoMerger:
         # look for track names in TRACKSFN file:
         tracks_file = source_audio_folder/TRACKSFN
         track_names = False
+        nchan = sox.file_info.channels(str(joined_audio))
         if os.path.isfile(tracks_file):
             logger.debug('found file: %s'%(TRACKSFN))
             track_dict = self._parse_track_values(tracks_file)
+            if track_dict['error msg']:
+                print('\nError parsing %s file: %s, quitting.\n'%(tracks_file,
+                                        track_dict['error msg']))
+                quit()
+
             logger.debug('parsed track_dict %s'%track_dict)
+            n_IDied_chan = 2*len(track_dict['stereomics'])
+            n_IDied_chan += len(track_dict['mix'])
+            n_IDied_chan += len(track_dict['0'])
+            n_IDied_chan += len(track_dict['others'])
+            n_IDied_chan += 1 # for ttc track
+            logger.debug(' n chan: %i n tracks file: %i'%(nchan, n_IDied_chan))
+            if n_IDied_chan != nchan:
+                print('\nError parsing %s content'%tracks_file)
+                print('incoherent number of tracks, %i vs %i quitting\n'%
+                                                    (nchan, n_IDied_chan))
+                # quit()
             err_msg = track_dict['error msg']
             if  err_msg != None:
                 print('Error, quitting: in file %s, %s'%(tracks_file, err_msg))
                 raise Exception
         else:
             logger.debug('no tracks.txt file found')
-        if IO_structure == 'foldercam':
+        if write_ISOs:
             # build ISOs subfolders structure, see comment string below
             video_stem_WO_suffix = synced_clip_file.stem.split('.')[0]
             D1, D2 = ISOsDIR.split('/')
@@ -561,11 +581,6 @@ class AudioStitcherVideoMerger:
             logger.debug('will split audio to %s'%(ISOdir))
             shutil.copy(joined_audio, ISO_multi_chan)
             filepath = str(ISO_multi_chan)
-            nchan = sox.file_info.channels(str(ISO_multi_chan))
-            if track_names and nchan != len(track_names):
-                print('error parsing %s content'%tracks_file)
-                print('incoherent number of tracks, quitting\n')
-                quit()
             for n in range(nchan):
                 if track_names:
                     iso_destination = ISOdir / (track_names[n]+'.wav')
@@ -599,7 +614,6 @@ class AudioStitcherVideoMerger:
                     canon24fps02.MOV
         """
 
-
     def _keep_VIDEO_only(self, video_path):
         # return file handle to a temp video file formed from the video_path
         # stripped of its sound
@@ -701,7 +715,7 @@ class Matcher:
 
     """
 
-    def __init__(self, recordings_list, IO_structure):
+    def __init__(self, recordings_list):
         """        
         At this point in the program, all recordings in recordings_list should
         have a valid Recording.start_time attribute and one of its channels
@@ -711,31 +725,31 @@ class Matcher:
         """
         self.recordings = recordings_list
         self.video_mergers = []
-        self._rename_all_recs(IO_structure)
+        # self._rename_all_recs(IO_structure)
 
 
-    def _rename_all_recs(self, IO_structure):
+    def _rename_all_recs(self):
         """
         Add _synced to filenames of synced video files. Change stored name only:
         files have yet to be written to.
         """
-        match IO_structure:
-            case 'foldercam':
-                for rec in self.recordings:
-                    rec_extension = rec.AVpath.suffix
-                    rel_path_new_name = '%s%s'%(rec.AVpath.stem, rec_extension)
-                    rec.new_rec_name = Path(rel_path_new_name)
-                    logger.debug('for %s new name: %s'%(
-                        _pathname(rec.AVpath),
-                        _pathname(rec.new_rec_name)))
-            case 'loose':
-                for rec in self.recordings:
-                    rec_extension = rec.AVpath.suffix
-                    rel_path_new_name = '%s%s%s'%('ttsd_',rec.AVpath.stem, rec_extension)
-                    rec.new_rec_name = Path(rel_path_new_name)
-                    logger.debug('for %s new name: %s'%(
-                        _pathname(rec.AVpath),
-                        _pathname(rec.new_rec_name)))
+        # match IO_structure:
+            # case 'foldercam':
+        for rec in self.recordings:
+            rec_extension = rec.AVpath.suffix
+            rel_path_new_name = '%s%s'%(rec.AVpath.stem, rec_extension)
+            rec.new_rec_name = Path(rel_path_new_name)
+            logger.debug('for %s new name: %s'%(
+                _pathname(rec.AVpath),
+                _pathname(rec.new_rec_name)))
+            # case 'loose':
+            #     for rec in self.recordings:
+            #         rec_extension = rec.AVpath.suffix
+            #         rel_path_new_name = '%s%s%s'%('ttsd_',rec.AVpath.stem, rec_extension)
+            #         rec.new_rec_name = Path(rel_path_new_name)
+            #         logger.debug('for %s new name: %s'%(
+            #             _pathname(rec.AVpath),
+            #             _pathname(rec.new_rec_name)))
 
     def scan_audio_for_each_ref_rec(self):
         """

tictacsync/yaltc.py

@@ -68,42 +68,42 @@ N_SYMBOLS_SAMD21 = 35 # including sync pulse
 
 BPF_LOW_FRQ, BPF_HIGH_FRQ = (0.5*F1, 2*F2)
 
-try:
-    layouts, _ = (
-    ffmpeg.input('').output('')
-    .global_args("-loglevel", "quiet","-nostats","-hide_banner","-layouts")
-    .run(capture_stdout=True)
-    )
-except ffmpeg.Error as e:
-    print('error',e.stderr)        
-
-
-
-names_str, layouts = [l.split('\n') for l in 
-    layouts.decode("utf-8").split('DECOMPOSITION')]
-[names_str.pop(0) for i in range(2)]
-[names_str.pop(-1) for i in range(3)]
-layouts.pop(0)
-layouts.pop(-1)
-channel_name_regex = re.compile(r'(\w+)\s+(.+)')
-layouts_regex = re.compile(r'(\S+)\s+(.+)')
-FFMPEG_CHAN_NAMES = [
-    channel_name_regex.match(name).group(1)
-    for name in names_str
-]
-FFMPEG_LAYO_NAMES = dict([
-    layouts_regex.match(lay_out).groups()
-    for lay_out in layouts
-])
-
-"""
-FFMPEG_CHAN_NAMES are the names used by ffmpeg for channels, eg: FL, FR, FC for
-front left, front right and front center.
-FFMPEG_LAYO_NAMES are the order of channels for each layout, eg: stereo is FL+FR
-and 5.1 is FL+FR+FC+LFE+BL+BR. Layout names are the dict keys.
-Run ffmpeg -layouts for details.
-
-"""
+# try:
+#     layouts, _ = (
+#     ffmpeg.input('').output('')
+#     .global_args("-loglevel", "quiet","-nostats","-hide_banner","-layouts")
+#     .run(capture_stdout=True)
+#     )
+# except ffmpeg.Error as e:
+#     print('error',e.stderr)        
+
+
+
+# names_str, layouts = [l.split('\n') for l in 
+#     layouts.decode("utf-8").split('DECOMPOSITION')]
+# [names_str.pop(0) for i in range(2)]
+# [names_str.pop(-1) for i in range(3)]
+# layouts.pop(0)
+# layouts.pop(-1)
+# channel_name_regex = re.compile(r'(\w+)\s+(.+)')
+# layouts_regex = re.compile(r'(\S+)\s+(.+)')
+# FFMPEG_CHAN_NAMES = [
+#     channel_name_regex.match(name).group(1)
+#     for name in names_str
+# ]
+# FFMPEG_LAYO_NAMES = dict([
+#     layouts_regex.match(lay_out).groups()
+#     for lay_out in layouts
+# ])
+
+# """
+# FFMPEG_CHAN_NAMES are the names used by ffmpeg for channels, eg: FL, FR, FC for
+# front left, front right and front center.
+# FFMPEG_LAYO_NAMES are the order of channels for each layout, eg: stereo is FL+FR
+# and 5.1 is FL+FR+FC+LFE+BL+BR. Layout names are the dict keys.
+# Run ffmpeg -layouts for details.
+
+# """
 
 # utility for accessing pathnames
 def _pathname(tempfile_or_path):
@@ -620,7 +620,6 @@ class Decoder:
                 format="png")
             plt.close()
 
-
     def _detect_sync_pulse_position(self):
         """
         Determines noise level during silence period and use it to detect the
@@ -1022,10 +1021,13 @@ class Recording:
         probe : dict
             returned value of ffmpeg.probe(self.AVpath)
 
-        YaLTC_channel : tuple of int
-            which channel is sync track, 0 for left or mono, 
-            1 for right. Value is None if not YaLTC found.
-            Set in _read_sound_extract().
+        YaLTC_channel : int
+            which channel is sync track. 0 is first channel,
+            set in _read_sound_find_YaLTC().
+
+        silent_channels : list of ints
+            list of channel which are silent. 1 is first channel,
+            set in _strip_yaltc()
 
         decoder : yaltc.decoder
             associated decoder object, if file is audiovideo
@@ -1461,6 +1463,8 @@ class Recording:
         Returns a tempfile.NamedTemporaryFile of sound file stripped
         of YaLTC channel and of any silent channel. Criteria for
         silence is sox stats "RMS lev db" < DB_RMS_SILENCE_SOX
+
+        Sets self.silent_channels
         """
         input_file = _pathname(self.AVpath)
         # building dict according to pysox.remix format.
@@ -1472,12 +1476,12 @@ class Recording:
         _, _, stat_output = sox.core.sox(args)
         sox_RMS_lev_dB = stat_output.split('\n')[5].split()[4:]
         logger.debug('Sox RMS %s, n_channels %i'%(sox_RMS_lev_dB, n_channels))
-        silent_channel = [i + 1 for i,db in enumerate(sox_RMS_lev_dB)
+        self.silent_channels = [i + 1 for i,db in enumerate(sox_RMS_lev_dB)
                                             if float(db) < DB_RMS_SILENCE_SOX]
-        logger.debug('silent chans (1st = #1) %s'%silent_channel)
+        logger.debug('silent chans (1st = #1) %s'%self.silent_channels)
         chan_list_out = range(1, n_channels) # eg [1,2,3]
         all_channels = range(1, n_channels + 1) # eg [1,2,3,4]
-        excluded_chans = silent_channel + [YaLTC_channel]
+        excluded_chans = self.silent_channels + [YaLTC_channel]
         logger.debug('excluded chans %s'%excluded_chans)
         kept_chans = [[n] for n in all_channels if n not in excluded_chans]
         # eg [[1], [3], [4]]

{tictacsync-0.1a13.dist-info → tictacsync-0.1a15.dist-info}/METADATA

@@ -1,8 +1,8 @@
 Metadata-Version: 2.1
 Name: tictacsync
-Version: 0.1a13
+Version: 0.1a15
 Summary: command for syncing audio video recordings
-Home-page: https://sr.ht/~proflutz/TicTacSync/
+Home-page: https://tictacsync.org/
 Author: Raymond Lutz
 Author-email: lutzrayblog@mac.com
 Classifier: Development Status :: 2 - Pre-Alpha

tictacsync-0.1a15.dist-info/RECORD

@@ -0,0 +1,13 @@
+tictacsync/LTCcheck.py,sha256=SUq93zfky5njzvnsnIj-5nC01QYf3hVBegJftPOFeJQ,15708
+tictacsync/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tictacsync/device_scanner.py,sha256=wDkhE_H33Zh5RIjASS33HOmX5-qI-dJ3h9yyvaTrAI0,15177
+tictacsync/entry.py,sha256=ICTDI6ZPaPsDnkZX-c7dahr6qpG09x618j9nPh3x2jM,10279
+tictacsync/multi2polywav.py,sha256=7Qnb986D3HJIAkNJ3IyvPWxIdqqh3KIfwnwFoUBw0pU,7013
+tictacsync/timeline.py,sha256=1NpfbvBv24oDtet8SafPcpvk5ppK8qTdEybs8qz8gkc,39258
+tictacsync/yaltc.py,sha256=Hu827V61yp1VcjZHJ9HMlCL_EEcxlhi_4hesOQy66bc,71391
+tictacsync-0.1a15.dist-info/LICENSE,sha256=ZAOPXLh1zlQAnhHUd7oLslKM01YZ5UiAu3STYjwIxck,1068
+tictacsync-0.1a15.dist-info/METADATA,sha256=oHbCfMD9Ar3utJci8OLQ-Sx-VlUbz9ZtfWYj26KoTs0,4206
+tictacsync-0.1a15.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
+tictacsync-0.1a15.dist-info/entry_points.txt,sha256=bre_DmdWFgHljcC0cyqh_dC9siGANO04MQ_wYsO2sxY,135
+tictacsync-0.1a15.dist-info/top_level.txt,sha256=eaCWG-BsYTRR-gLTJbK4RfcaXajr0gjQ6wG97MkGRrg,11
+tictacsync-0.1a15.dist-info/RECORD,,

tictacsync-0.1a13.dist-info/RECORD

@@ -1,13 +0,0 @@
-tictacsync/LTCcheck.py,sha256=SUq93zfky5njzvnsnIj-5nC01QYf3hVBegJftPOFeJQ,15708
-tictacsync/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-tictacsync/device_scanner.py,sha256=7fIYyzbrhDj1slBUkO6O1aqD81vUa-8uTaD7pBs178o,13604
-tictacsync/entry.py,sha256=TU1n_dBPYP329zOMj-gJ23kRskRK2ZYZLjCBAD1GcVc,9997
-tictacsync/multi2polywav.py,sha256=7Qnb986D3HJIAkNJ3IyvPWxIdqqh3KIfwnwFoUBw0pU,7013
-tictacsync/timeline.py,sha256=bIyi3vARsGKDGz0m3DfRsp6nw-HAyuj2VY9vkcFDqWQ,38690
-tictacsync/yaltc.py,sha256=6YqqdFEnOgP9MkPWgps4HOPb0BI2NFUixqrMkSQFpE0,71203
-tictacsync-0.1a13.dist-info/LICENSE,sha256=ZAOPXLh1zlQAnhHUd7oLslKM01YZ5UiAu3STYjwIxck,1068
-tictacsync-0.1a13.dist-info/METADATA,sha256=O3LTSHFLvWgsmLX_MDbN_26e6VdkgUnSVbU-tsKaWPE,4218
-tictacsync-0.1a13.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
-tictacsync-0.1a13.dist-info/entry_points.txt,sha256=bre_DmdWFgHljcC0cyqh_dC9siGANO04MQ_wYsO2sxY,135
-tictacsync-0.1a13.dist-info/top_level.txt,sha256=eaCWG-BsYTRR-gLTJbK4RfcaXajr0gjQ6wG97MkGRrg,11
-tictacsync-0.1a13.dist-info/RECORD,,