tictacsync 1.0.0a0__tar.gz → 1.0.2a0__tar.gz

{tictacsync-1.0.0a0/tictacsync.egg-info → tictacsync-1.0.2a0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: tictacsync
-Version: 1.0.0a0
+Version: 1.0.2a0
 Summary: command for syncing audio video recordings
 Home-page: https://tictacsync.org/
 Author: Raymond Lutz
@@ -58,7 +58,7 @@ Then pip install the syncing program:
 This should install python dependencies _and_ the `tictacsync` command.
 ## Usage
 
-Download multiple sample files [here](https://nuage.lutz.quebec/s/P3gbZR4GgGy8xQp/download/dailies1_1.zip) (625 MB, sorry) unzip and run:
+Download multiple sample files [here](https://nuage.lutz.quebec/s/D4DgzHrLaAjqNmY) (625 MB, sorry) unzip and run:
 
     > tictacsync dailies/loose
 The program `tictacsync` will recursively scan the directory given as argument, find all audio that coincide with any video and merge them into a subfolder named `SyncedMedia`. When the argument is an unique media file (not a directory), no syncing will occur but the decoded starting time will be printed to stdout:

{tictacsync-1.0.0a0 → tictacsync-1.0.2a0}/README.md

@@ -35,7 +35,7 @@ Then pip install the syncing program:
 This should install python dependencies _and_ the `tictacsync` command.
 ## Usage
 
-Download multiple sample files [here](https://nuage.lutz.quebec/s/P3gbZR4GgGy8xQp/download/dailies1_1.zip) (625 MB, sorry) unzip and run:
+Download multiple sample files [here](https://nuage.lutz.quebec/s/D4DgzHrLaAjqNmY) (625 MB, sorry) unzip and run:
 
     > tictacsync dailies/loose
 The program `tictacsync` will recursively scan the directory given as argument, find all audio that coincide with any video and merge them into a subfolder named `SyncedMedia`. When the argument is an unique media file (not a directory), no syncing will occur but the decoded starting time will be printed to stdout:

{tictacsync-1.0.0a0 → tictacsync-1.0.2a0}/setup.py

@@ -33,7 +33,7 @@ setup(
         'multi2polywav = tictacsync.multi2polywav:main',
         ]
         },
-    version = '1.0.0-alpha',
+    version = '1.0.2-alpha',
     description = "command for syncing audio video recordings",
     long_description_content_type='text/markdown',
     long_description = long_descr,

{tictacsync-1.0.0a0 → tictacsync-1.0.2a0}/tictacsync/device_scanner.py

@@ -19,7 +19,7 @@ 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()
 
 from dataclasses import dataclass
-import ffmpeg, os, sys
+import ffmpeg, os, sys, shutil
 from os import listdir
 from os.path import isfile, join, isdir
 from collections import namedtuple
@@ -28,7 +28,7 @@ from pprint import pformat
 # from collections import defaultdict
 from loguru import logger
 # import pathlib, os.path
-import sox, tempfile
+import sox, tempfile, platformdirs, filecmp
 # from functools import reduce
 from rich import print
 from itertools import groupby
@@ -36,8 +36,10 @@ from itertools import groupby
 # import distance
 try:
     from . import multi2polywav
+    from . import mamsync
 except:
     import multi2polywav
+    import mamsync
 
 MCCDIR = 'SyncedMulticamClips'
 SYNCEDFOLDER = 'SyncedMedia'
@@ -244,16 +246,7 @@ class Scanner:
         CAMs = [d for d in devices if d.dev_type == 'CAM']
         return len(set(CAMs))
 
-    def get_device_in_path(self, a_media):
-        """
-        Return a device name taken from folders in path of a_media if and only
-        if all media files below it are from the same device. Goes up max two
-        levels from media; e.g., in /FOLDER2/FOLDER1/DSC00234.MOV will test up
-        to FOLDER2 as candidate.
-        """
-
-
-    def scan_media_and_build_devices_UID(self, recursive=True):
+    def scan_media_and_build_devices_UID(self, synced_root = None):
         """
         Scans Scanner.top_directory recursively for files with known audio-video
         extensions. For each file found, a device fingerprint is obtained from
@@ -269,20 +262,59 @@ class Scanner:
         Sets Scanner.input_structure = 'loose'|'ordered'
 
         """
-        files = Path(self.top_directory).rglob('*.*')
-        def _last4letters(part):
-            return
-
-        paths = [
-            p
-            for p in files
-            if p.suffix[1:] in av_file_extensions
-            and SYNCEDFOLDER not in p.parts # SyncedMedia
-            and MCCDIR not in p.parts # SyncedMulticamClips
-            and '_ISO' not in [part[-4:] for part in p.parts] # exclude ISO wav files
-        ]
-        logger.debug('found media files %s'%paths)
-        parents = [p.parent for p in paths]
+        logger.debug(f'on entry synced_root: {synced_root}')
+        if synced_root != None: # mam mode
+            p = Path(platformdirs.user_data_dir('mamsync', 'plutz'))/mamsync.LOG_FILE
+            with open(p, 'r') as fh:
+                done = set(fh.read().split()) # sets of strings of abs path
+            logger.debug(f'done clips: {pformat(done)}')
+        files = Path(self.top_directory).rglob('*')
+        clip_paths = []
+        some_done = False
+        for raw_path in files:
+            if raw_path.suffix[1:] in av_file_extensions:
+                if SYNCEDFOLDER not in raw_path.parts: # SyncedMedia
+                    if MCCDIR not in raw_path.parts: # SyncedMulticamClips
+                        if '_ISO' not in [part[-4:] for part in raw_path.parts]: # exclude ISO wav files
+                            if synced_root != None and str(raw_path) in done:
+                                logger.debug(f'{raw_path} done')
+                                some_done = True
+                                continue
+                            else:
+                                clip_paths.append(raw_path)
+############################################################ MOVE
+            elif synced_root != None: # MAM mode
+                #non AV files and directories
+                synced_path = Path(synced_root)/str(raw_path)[1:] # cant join abs. paths
+                if raw_path.is_dir():
+                        synced_path.mkdir(parents=True, exist_ok=True)
+                        continue
+                # if here, it's a file
+                if not synced_path.exists():
+                    print(f'will mirror non AV file at {synced_path}')
+                    logger.debug(f'will mirror non AV file at {synced_path}')
+                    shutil.copy2(raw_path, synced_path)
+                    continue
+                # file exists, check if same
+                same = filecmp.cmp(raw_path, synced_path, shallow=False)
+                logger.debug(f'copy exists of:\n{raw_path}\n{synced_path}')
+                if not same:
+                    print(f'file changed, copying again\n{raw_path}')
+                    shutil.copy2(raw_path, synced_path)
+                else:
+                    logger.debug('same content, next')
+                    continue # next raw_path in loop
+###################################################################
+        if some_done:
+            print('Somme media files were already synced...')
+        logger.debug('found media files %s'%clip_paths)
+        if len(clip_paths) == 0:
+            print('No media found, bye.')
+            sys.exit(0)
+            # self.found_media_files = []
+            # self.input_structure = 'loose'
+            # return
+        parents = [p.parent for p in clip_paths]
         logger.debug('found parents %s'%pformat(parents))
         # True if all elements are identical
         AV_files_have_same_parent = parents.count(parents[0]) == len(parents)
@@ -296,7 +328,7 @@ class Scanner:
             # check later if inside each folder, media have same device
             # for now, we'll guess structure is 'ordered'
             self.input_structure = 'ordered'
-        for p in paths:
+        for p in clip_paths:
             new_media = media_at_path(self.input_structure, p) # dev UID set here
             self.found_media_files.append(new_media)
         # for non UIDed try building UID from filenam
@@ -379,7 +411,7 @@ class Scanner:
         no_name_devices = [m.device for m in self.found_media_files
                                             if not m.device.name]
                             # possible if self.input_structure == 'loose'
-        def _try_name_from_metadata(media):
+        def _try_name_from_metadata(media): # unused for now
             # search model and make from fprobe
             file = Path(media.path)
             logger.debug('trying to find maker model for %s'%file)
@@ -395,7 +427,6 @@ class Scanner:
             # could reside in ['format','tags','com.apple.quicktime.model'],
             # or ['format','tags','model'],
             # or ['streams'][0]['tags']['vendor_id'])  :-(
-
         for anon_dev in no_name_devices:
             medias = self.get_media_for_device(anon_dev)
             guess_name = _try_name_from_files(medias)

{tictacsync-1.0.0a0 → tictacsync-1.0.2a0}/tictacsync/entry.py

@@ -2,7 +2,7 @@
 # I know, the following is ugly, but I need those try's to
 # run the command in my dev setting AND from
 # a deployment set-up... surely I'm setting
-# things wrong [TODO] find why and clean up this mess
+# things wrong [TODO]: find why and clean up this mess
 
 try:
     from . import yaltc
@@ -40,23 +40,6 @@ ogg oga mogg opus ra rm raw rf64 sln tta voc vox wav wma wv webm 8svx cda""".spl
 
 logger.level("DEBUG", color="<yellow>")
 
-# def process_files_with_progress_bars(medias): # [todo, replace]
-#     recordings = []
-#     rec_with_TTC = []
-#     times = []
-#     for m in track(medias,
-#             description="1/4 Initializing Recordings:"):
-#         # file_alias = 'dummy'
-#         recordings.append(yaltc.Recording(m))
-#     for r in track(recordings,
-#             description="2/4  Looking for TicTacCode:"):
-#         if r.seems_to_have_TicTacCode_at_beginning():
-#             rec_with_TTC.append(r)
-#     for r in track(rec_with_TTC,
-#             description="3/4     Finding start times:"):
-#         times.append(r.get_start_time())
-#     return recordings, rec_with_TTC, times
-
 def process_single(file, args):
     # argument is a single file
     m = device_scanner.media_at_path(None, Path(file))
@@ -122,61 +105,6 @@ def process_lag_adjustement(media_object):
     logger.debug('trimmed_multichanfile %s'%timeline._pathname(trimmed_multichanfile))
     Path(timeline._pathname(trimmed_multichanfile)).replace(media_object.path)
 
-def start_proj(folders):
-    # if existing values are found,
-    # confirm new values with user.
-    # returns (source_RAW, destination_synced)
-    # either old (and confirmed) or new ones
-    def _write_cfg():
-        conf_dir = platformdirs.user_config_dir('tictacsync', 'plutz',
-                                                    ensure_exists=True)
-        logger.debug('will start project with folders %s'%folders)
-        conf_file = Path(conf_dir)/'mirrored.cfg'
-        logger.debug('writing config in %s'%conf_file)
-        conf_prs = configparser.ConfigParser()
-        conf_prs['MIRRORED'] = {'source_RAW': folders[0],
-                                'destination_synced': folders[1]}
-        with open(conf_file, 'w') as configfile:
-            conf_prs.write(configfile)
-    known_values = get_proj()
-    if known_values != ():
-        source_RAW, destination_synced = known_values
-        print('Warning: there is a current project')
-        print('with source (RAW) folder: %s\nand destination (synced) folder: %s'%
-                                            (source_RAW, destination_synced))
-        answer = input("\nDo you want to change values? [YES|NO]")
-        if answer.upper()[0] in ["Y", "YES"]:
-            _write_cfg()
-            return folders
-        elif answer.upper()[0] in ["N", "NO"]:
-            print('Ok, will keep old ones')
-            return source_RAW, destination_synced
-    else:
-        _write_cfg()
-        return folders
-
-    sys.exit(0)
-
-def get_proj():
-    # check if user started a project before.
-    # stored in platformdirs.user_config_dir
-    # returns (source_RAW, destination_synced) if any
-    # () otherwise 
-    conf_dir = platformdirs.user_config_dir('tictacsync', 'plutz')
-    conf_file = Path(conf_dir)/'mirrored.cfg'
-    if conf_file.exists():
-        logger.debug('reading config in %s'%conf_file)
-        conf_prs = configparser.ConfigParser()
-        conf_prs.read(conf_file)
-        source_RAW = conf_prs.get('MIRRORED', 'source_RAW')
-        destination_synced = conf_prs.get('MIRRORED', 'destination_synced')
-        logger.debug('read source_RAW: %s and destination_synced: %s'%
-                                            (source_RAW, destination_synced))
-        return (source_RAW, destination_synced)
-    else:
-        logger.debug('no config file found')
-        return ()
-
 def main():
     parser = argparse.ArgumentParser()
     parser.add_argument(
@@ -191,15 +119,15 @@ def main():
                         action='store_true',  #ie default False
                         dest='verbose_output',
                         help='Set verbose ouput')
-    parser.add_argument('--stop_mirroring',
-                        action='store_true',  #ie default False
-                        dest='stop_mirroring',
-                        help='Stop mirroring mode, will write synced files alongside originals.')
-    parser.add_argument('--start-project', '-s' ,
-                    nargs=2,
-                    dest='proj_folders',
-                    default = [],
-                    help='start mirrored tree output mode and specifies 2 folders: source (RAW) and destination (synced).')
+    # parser.add_argument('--stop_mirroring',
+    #                     action='store_true',  #ie default False
+    #                     dest='stop_mirroring',
+    #                     help='Stop mirroring mode, will write synced files alongside originals.')
+    # parser.add_argument('--start-project', '-s' ,
+    #                 nargs=2,
+    #                 dest='proj_folders',
+    #                 default = [],
+    #                 help='start mirrored tree output mode and specifies 2 folders: source (RAW) and destination (synced).')
     parser.add_argument('-t','--timelineoffset',
                     nargs=1,
                     default=['00:00:00:00'],
@@ -242,33 +170,10 @@ def main():
     # logger.add(sys.stdout, filter="__main__")
     # logger.add(sys.stdout, filter="yaltc")
 
-    # logger.add(sys.stdout, filter=lambda r: r["function"] == "start_proj")
+    logger.add(sys.stdout, filter=lambda r: r["function"] == "start_proj")
     # logger.add(sys.stdout, filter=lambda r: r["function"] == "_dev_type_for_name")
     # logger.add(sys.stdout, filter=lambda r: r["function"] == "scan_media_and_build_devices_UID")
 
-
-    if args.proj_folders != []:
-        print('\bSorry, mirrored output mode not implemented yet: synced clips will')
-        print('be written alongside originals in a SyncedMedia folder. Bye.')
-        sys.exit(0)
-    
-    if not len(args.proj_folders) in [0, 2]:
-        print('Error, -s option requires two folders')
-        sys.exit(0)
-    if len(args.proj_folders) == 2:
-        source_RAW, destination_synced = start_proj(args.proj_folders)
-        logger.debug('source_RAW: %s destination_synced: %s'%(source_RAW,
-                                            destination_synced))
-    proj_folders = get_proj()
-    if proj_folders != ():
-        # mirrored mode
-        source_RAW, destination_synced = proj_folders
-        logger.debug('Mirrored mode ON, with %s '%str(proj_folders))
-    else:
-        source_RAW, destination_synced = None, None
-        logger.debug('Mirrored mode OFF, ')
-    if source_RAW or destination_synced:
-        print('Mirrored not implemented yet, ignoring.')
     top_dir = args.path[0]
     if os.path.isfile(top_dir):
         file = top_dir
@@ -276,15 +181,6 @@ def main():
     if not os.path.isdir(top_dir):
         print('%s is not a directory or doesnt exist.'%top_dir)
         sys.exit(1)
-    # logger.debug('args.o %s'%args.o)
-    # print('args.o %s'%args.o)
-    # if args.anchor:
-    #     anchor_dir = args.anchor[0]
-    # else:
-    #     anchor_dir = None
-    # if args.anchor and not os.path.isdir(anchor_dir):
-    #     print('%s is not a directory or doesnt exist.'%anchor_dir)
-    #     sys.exit(1)
     multi2polywav.poly_all(top_dir)
     scanner = device_scanner.Scanner(top_dir, stay_silent=args.terse)
     scanner.scan_media_and_build_devices_UID()
@@ -406,13 +302,6 @@ def main():
         console.print(table)
         print()
     n_devices = scanner.get_devices_number()
-    # OUT_struct_for_mcam =   scanner.top_dir_has_multicam and \
-    #                         scanner.input_structure != 'loose'
-    # OUT_struct_for_mcam = args.multicam
-    # if OUT_struct_for_mcam and scanner.input_structure == 'loose':
-    #     print("\nSorry, can't output multicam structure if input is not structured:")
-    #     print("each camera must have its own folder with its clips stored inside, quitting.")
-    #     sys.exit(0)
     if len(recordings_with_time) < 2:
         if not args.terse:
             print('\nNothing to sync, exiting.\n')
@@ -429,6 +318,7 @@ def main():
         asked_ISOs = False
     # output_dir = args.o
     # if args.verbose_output or args.terse: # verbose, so no progress bars
+    print('Merging...')
     for merger in matcher.mergers:
         merger.build_audio_and_write_merged_media(top_dir,
         args.dont_write_cam_folder,

tictacsync-1.0.2a0/tictacsync/mamsync.py

@@ -0,0 +1,460 @@
+
+# I know, the following is ugly, but I need those try's to
+# run the command in my dev setting AND from
+# a deployment set-up... surely I'm setting
+# things wrong [TODO]: find why and clean up this mess
+
+try:
+    from . import yaltc
+    from . import device_scanner
+    from . import timeline
+    from . import multi2polywav
+except:
+    import yaltc
+    import device_scanner
+    import timeline
+    import multi2polywav
+
+import argparse, tempfile, configparser
+from loguru import logger
+from pathlib import Path
+# import os, sys
+import os, sys, sox, platformdirs
+from rich.progress import track
+# from pprint import pprint
+from rich.console import Console
+# from rich.text import Text
+from rich.table import Table
+from rich import print
+from pprint import pprint, pformat
+import numpy as np
+
+DEL_TEMP = False
+CONF_FILE = 'mamsync.cfg'
+LOG_FILE = 'mamdone.txt'
+
+av_file_extensions = \
+"""MOV webm mkv flv flv vob ogv ogg drc gif gifv mng avi MTS M2TS TS mov qt
+wmv yuv rm rmvb viv asf amv mp4 m4p m4v mpg mp2 mpeg mpe mpv mpg mpeg m2v
+m4v svi 3gp 3g2 mxf roq nsv flv f4v f4p f4a f4b 3gp aa aac aax act aiff alac
+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""".split()
+
+# logger.add(sys.stdout, level="DEBUG")
+
+
+# logger.add(sys.stdout, filter=lambda r: r["function"] == "scan_media_and_build_devices_UID")
+# logger.add(sys.stdout, filter=lambda r: r["function"] == "main")
+
+
+def process_single(file, args):
+    # argument is a single file
+    m = device_scanner.media_at_path(None, Path(file))
+    if args.plotting:
+        print('\nPlots can be zoomed and panned...')
+        print('Close window for next one.')
+    a_rec = yaltc.Recording(m, do_plots=args.plotting)
+    time = a_rec.get_start_time()
+    # time = a_rec.get_start_time(plots=args.plotting)
+    if time != None:
+        frac_time = int(time.microsecond / 1e2)
+        d = '%s.%s'%(time.strftime("%Y-%m-%d %H:%M:%S"),frac_time)
+        if args.terse:
+            print('%s UTC:%s pulse: %i in chan %i'%(file, d, a_rec.sync_position,
+                        a_rec.TicTacCode_channel))
+        else:
+            print('\nRecording started at [gold1]%s[/gold1] UTC'%d)
+            print('true sample rate: [gold1]%.3f Hz[/gold1]'%a_rec.true_samplerate)
+            print('first sync at [gold1]%i[/gold1] samples in channel %i'%(a_rec.sync_position,
+                        a_rec.TicTacCode_channel))
+            print('N.B.: all results are precise to the displayed digits!\n')
+    else:
+        if args.terse:
+            print('%s UTC: None'%(file))
+        else:
+            print('Start time couldnt be determined')
+    sys.exit(1)
+
+def process_lag_adjustement(media_object):
+    # trim channels that are lagging (as stated in tracks.txt)
+    # replace the old file, and rename the old one with .wavbk
+    # if .wavbk exist, process was done already, so dont process
+    # returns nothing
+    lags = media_object.device.tracks.lag_values
+    logger.debug('will process %s lags'%[lags])
+    channels = timeline._sox_split_channels(media_object.path)
+    # add bk to file on filesystem, but media_object.path is unchanged (?)
+    backup_name = str(media_object.path) + 'bk'
+    if Path(backup_name).exists():
+        logger.debug('%s exists, so return now.'%backup_name)
+        return
+    media_object.path.replace(backup_name)
+    logger.debug('channels %s'%channels)
+    def _trim(lag, chan_file):
+        # for lag
+        if lag == None:
+            return chan_file
+        else:
+            logger.debug('process %s for lag of %s'%(chan_file, lag))            
+            sox_transform = sox.Transformer()
+            sox_transform.trim(float(lag)*1e-3)
+            output_fh = tempfile.NamedTemporaryFile(suffix='.wav', delete=DEL_TEMP)
+            out_file = timeline._pathname(output_fh)
+            input_file = timeline._pathname(chan_file)
+            logger.debug('sox in and out files: %s %s'%(input_file, out_file))
+            logger.debug('calling sox_transform.build()')
+            status = sox_transform.build(input_file, out_file, return_output=True )
+            logger.debug('sox.build exit code %s'%str(status))
+        return output_fh
+    new_channels = [_trim(*e) for e in zip(lags, channels)]
+    logger.debug('new_channels %s'%new_channels)
+    trimmed_multichanfile = timeline._sox_combine(new_channels)
+    logger.debug('trimmed_multichanfile %s'%timeline._pathname(trimmed_multichanfile))
+    Path(timeline._pathname(trimmed_multichanfile)).replace(media_object.path)
+
+def print_out_conf(raw_root, synced_root, snd_root):
+    print(f'RAWROOT (source with TC): "{raw_root}"')
+    print(f'SYNCEDROOT (destination of synced clips): "{synced_root}"')
+    print(f'SNDROOT (destination of ISOs files): "{snd_root}"')
+
+def clear_log():
+    # clear the file logging clips already synced
+    data_dir = platformdirs.user_data_dir('mamsync', 'plutz', ensure_exists=True)
+    log_file = Path(data_dir)/LOG_FILE
+    print('Clearing log file "%s"'%log_file)
+    with open(log_file, 'w') as fh:
+        fh.write('done:\n')
+
+def write_conf(raw_root, synced_root, snd_root):
+    # args are pahtlib.Paths.
+    # RAWROOT: files with TC (and ROLL folders), as is from cameras
+    # SYNCEDROOT: synced and no more TC (ROLL flattened)
+    # Writes configuration on filesystem for later retrieval
+    # Clears log of already synced clips.
+    conf_dir = platformdirs.user_config_dir('mamsync', 'plutz', ensure_exists=True)
+    logger.debug(f'will start project with raw_root:{raw_root}, synced_root:{synced_root}')
+    conf_file = Path(conf_dir)/CONF_FILE
+    logger.debug('writing config in %s'%conf_file)
+    print(f'\nWriting folders paths in configuration file "{conf_file}"')
+    print_out_conf(raw_root, synced_root, snd_root)
+    conf_prs = configparser.ConfigParser()
+    conf_prs['SECTION1'] = {'RAWROOT': raw_root,
+                            'SYNCEDROOT': synced_root,
+                            'SNDROOT': snd_root}
+    with open(conf_file, 'w') as configfile_handle:
+        conf_prs.write(configfile_handle)
+    with open(conf_file, 'r') as configfile_handle:
+        logger.debug(f'config file content: \n{configfile_handle.read()}')
+    clear_log()
+
+
+
+    # if known_values != ():
+    #     RAWROOT, SYNCEDROOTS = known_values
+    #     print('Warning: there is a current project')
+    #     print('with source (RAW) folder: %s\nand destination (synced) folder: %s'%
+    #                                         (RAWROOT, SYNCEDROOTS))
+    #     answer = input("\nDo you want to change values? [YES|NO]")
+    #     if answer.upper()[0] in ["Y", "YES"]:
+    #         _write_cfg()
+    #         return folders
+    #     elif answer.upper()[0] in ["N", "NO"]:
+    #         print('Ok, will keep old ones')
+    #         return RAWROOT, SYNCEDROOTS
+    # else:
+    #     _write_cfg()
+    #     return folders
+    # sys.exit(0)
+
+def get_proj(print_conf_stdout=False):
+    # check if user started a project before.
+    # stored in platformdirs.user_config_dir
+    # returns (RAWROOT, SYNCEDROOTS) if any, () otherwise.
+    # print location of conf file if print_conf_stdout
+    conf_dir = platformdirs.user_config_dir('mamsync', 'plutz')
+    conf_file = Path(conf_dir)/CONF_FILE
+    logger.debug('try reading config in %s'%conf_file)
+    if print_conf_stdout:
+        print(f'\nReading configuration from file {conf_file}')
+    if conf_file.exists():
+        conf_prs = configparser.ConfigParser()
+        conf_prs.read(conf_file)
+        RAWROOT = conf_prs.get('SECTION1', 'RAWROOT')
+        SYNCEDROOT = conf_prs.get('SECTION1', 'SYNCEDROOT')
+        SNDROOT = conf_prs.get('SECTION1', 'SNDROOT')
+        logger.debug('read from conf: RAWROOT= %s SYNCEDROOT= %s SNDROOT=%s'%
+                                            (RAWROOT, SYNCEDROOT, SNDROOT))
+        return RAWROOT, SYNCEDROOT, SNDROOT
+    else:
+        logger.debug(f'no config file found at {conf_file}')
+        return ()
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--rawfolder',
+                        nargs = 1,
+                        dest='rawfolder',
+                        help='Sets new value for raw root folder (i.e.: clips with TC)')
+    parser.add_argument('--syncedfolder',
+                        nargs = 1,
+                        dest='syncedfolder',
+                        help='Sets new value for synced root folder (i.e.: synced clips without TC)')
+    parser.add_argument('--sndfolder',
+                        nargs = 1,
+                        dest='sndfolder',
+                        help='Sets new value for sound folder (where ISOs will be stored)')
+    parser.add_argument('--showconf',
+                    action='store_true',
+                    dest='showconf',
+                    help='Show current configured values.')
+    parser.add_argument('--resync',
+                    action='store_true',
+                    dest='resync',
+                    help='Resync previously done clips.')
+    parser.add_argument(
+            "sub_dir",
+            type=str,
+            nargs='?',
+            help="Sub directory to scan, should under RAWROOT."
+            )
+    parser.add_argument('--terse',
+                    action='store_true',
+                    dest='terse',
+                    help='Terse output')
+    parser.add_argument('--isos',
+                    action='store_true',
+                    dest='write_ISOs',
+                    help='Cut ISO sound files')
+    parser.add_argument('-t','--timelineoffset',
+                    nargs=1,
+                    default=['00:00:00:00'],
+                    dest='timelineoffset',
+                    help='When processing multicam, where to place clips on NLE timeline (HH:MM:SS:FF)')
+    args = parser.parse_args()
+    logger.debug(f'arguments from argparse {args}')
+    # check --rawfolder, --syncedfolder and --sndfolder are used together
+    at_least_one = args.rawfolder != None or args.syncedfolder != None or args.sndfolder != None
+    tous = args.rawfolder != None and args.syncedfolder != None and args.sndfolder != None
+    if at_least_one:
+        if not tous:
+            print('Error: all --rawfolder, --syncedfolder and --sndfolder must be specified.')
+            sys.exit(0)
+        # check the 3 paths are ok
+        roots = [Path(e) for e in [args.rawfolder[0],
+                    args.syncedfolder[0], args.sndfolder[0]]]
+        for r in roots:
+            if not r.is_absolute():
+                print(f'\rError: folder {r} must be an absolute path. Bye')
+                sys.exit(0)
+            if not r.exists():
+                print(f'\rError: folder {r} does not exist. Bye')
+                sys.exit(0)
+            if not r.is_dir():
+                print(f'\rError: path {r} is not a folder. Bye')
+                sys.exit(0)
+            # if still here, everything in 3 folders is ok
+            write_conf(*roots)
+            sys.exit(0)
+    if args.showconf:
+        raw_root, synced_root = get_proj(True)
+        print_out_conf(raw_root, synced_root)
+        sys.exit(0)
+    # if still here,  no rawfolder, --syncedfolder --sndfolder or --showconf
+    # so go for a scan and sync, maybe with a sub_dir
+    raw_root, synced_root, snd_root = get_proj(False)
+    if args.sub_dir != None:
+        top_dir = args.sub_dir
+        logger.debug(f'sub _dir: {args.sub_dir}')
+        if not Path(top_dir).exists():
+            print(f"\rError: folder {top_dir} doesn't exist, bye.")
+            sys.exit(0)
+    else:
+        top_dir = raw_root
+    if args.resync:
+        clear_log()
+    multi2polywav.poly_all(top_dir)
+    scanner = device_scanner.Scanner(top_dir, stay_silent=args.terse)
+    scanner.scan_media_and_build_devices_UID(synced_root=synced_root)
+    for m in scanner.found_media_files:
+        if m.device.tracks:
+            if not all([lv == None for lv in m.device.tracks.lag_values]):
+                logger.debug('%s has lag_values %s'%(
+                        m.path, m.device.tracks.lag_values))
+                # any lag for a channel is specified by user in tracks.txt
+                process_lag_adjustement(m)
+    audio_REC_only = all([m.device.dev_type == 'REC' for m
+                                        in scanner.found_media_files])
+    # if audio_REC_only:
+    #     if scanner.input_structure != 'ordered':
+    #         print('For merging audio only, use a directory per device, quitting')
+    #         sys.exit(1)
+    #     print('\n\n\nOnly audio recordings are present')
+    #     print('Which device should be the reference?\n')
+    #     devices = scanner.get_devices()
+    #     maxch = len(devices)
+    #     for i, d in enumerate(devices):
+    #         print('\t%i - %s'%(i+1, d.name))
+    #     while True:
+    #         print('\nEnter your choice:', end='')
+    #         choice = input()
+    #         try:
+    #             choice = int(choice)
+    #         except:
+    #             print('Please use numeric digits.')
+    #             continue
+    #         if choice not in list(range(1, maxch + 1)):
+    #             print('Please enter a number in [1..%i]'%maxch)
+    #             continue
+    #         break
+    #     ref_device = list(devices)[choice - 1]
+    #     # ref_device = list(devices)[3 - 1]
+    #     print('When only audio recordings are present, ISOs files will be cut and written.')
+    if not args.terse:
+        if scanner.input_structure == 'ordered':
+            print('\nDetected structured folders')
+            # if scanner.top_dir_has_multicam:
+            #     print(', multicam')
+            # else:
+            #     print()
+        else:
+            print('\nDetected loose structure')
+            if scanner.CAM_numbers() > 1:
+                print('\nNote: different CAMs are present, will sync audio for each of them but if you want to set their')
+                print('respective timecode for NLE timeline alignement you should regroup clips by CAM under their own DIR.')
+        print('\nFound [gold1]%i[/gold1] media files '%(
+            len(scanner.found_media_files)), end='')
+        print('from [gold1]%i[/gold1] devices:\n'%(
+            scanner.get_devices_number()))
+        all_devices = scanner.get_devices()
+        for dev in all_devices:
+            dt = 'Camera' if dev.dev_type == 'CAM' else 'Recorder'
+            print('%s [gold1]%s[/gold1] with files:'%(dt, dev.name), end = ' ')
+            medias = scanner.get_media_for_device(dev)
+            for m in medias[:-1]: # last printed out of loop
+                print('[gold1]%s[/gold1]'%m.path.name, end=', ')
+            print('[gold1]%s[/gold1]'%medias[-1].path.name)
+            a_media = medias[0]
+        # check if all audio recorders have same sampling freq
+        freqs = [dev.sampling_freq for dev in all_devices if dev.dev_type == 'REC']
+        same = np.isclose(np.std(freqs),0)
+        logger.debug('sampling freqs from audio recorders %s, same:%s'%(freqs, same))
+        if not same:
+            print('some audio recorders have different sampling frequencies:')
+            print(freqs)
+            print('resulting in undefined results: quitting...')
+            quit()
+        print()
+    # recordings, rec_with_TTC = process_files(scanner.found_media_files, args)
+    recordings = [yaltc.Recording(m, do_plots=False) for m 
+                                            in scanner.found_media_files]
+    recordings_with_time =  [
+        rec 
+        for rec in recordings
+        if rec.get_start_time()
+        ]
+    # if audio_REC_only:
+    #     for rec in recordings:
+    #     # print(rec, rec.device == ref_device)
+    #         if rec.device == ref_device:
+    #             rec.is_reference = True
+    if not args.terse:    
+        table = Table(title="tictacsync results")
+        table.add_column("Recording\n", justify="center", style='gold1')
+        table.add_column("TTC chan\n (1st=#0)", justify="center", style='gold1')
+        # table.add_column("Device\n", justify="center", style='gold1')
+        table.add_column("UTC times\nstart:end", justify="center", style='gold1')
+        table.add_column("Clock drift\n(ppm)", justify="right", style='gold1')
+        # table.add_column("SN ratio\n(dB)", justify="center", style='gold1')
+        table.add_column("Date\n", justify="center", style='gold1')
+        rec_WO_time = [
+            rec.AVpath.name
+            for rec in recordings
+            if rec not in recordings_with_time]
+        if rec_WO_time:
+            print('No time found for: ',end='')
+            [print(rec, end=' ') for rec in rec_WO_time]
+            print('\n')
+        for r in recordings_with_time:
+            date = r.get_start_time().strftime("%y-%m-%d")
+            start_HHMMSS = r.get_start_time().strftime("%Hh%Mm%Ss")
+            end_MMSS = r.get_end_time().strftime("%Mm%Ss")
+            times_range = start_HHMMSS + ':' + end_MMSS
+            table.add_row(
+                str(r.AVpath.name),
+                str(r.TicTacCode_channel),
+                # r.device,
+                times_range,
+                # '%.6f'%(r.true_samplerate/1e3),
+                '%2i'%(r.get_samplerate_drift()),
+                # '%.0f'%r.decoder.SN_ratio,
+                date
+                )
+        console = Console()
+        console.print(table)
+        print()
+    n_devices = scanner.get_devices_number()
+    if len(recordings_with_time) < 2:
+        if not args.terse:
+            print('\nNothing to sync, exiting.\n')
+        sys.exit(1)
+    matcher = timeline.Matcher(recordings_with_time)
+    matcher.scan_audio_for_each_videoclip()
+    if not matcher.mergers:
+        if not args.terse:
+            print('\nNothing to sync, bye.\n')
+        sys.exit(1)
+    asked_ISOs = args.write_ISOs
+    if asked_ISOs and scanner.input_structure != 'ordered':
+        print('Warning, can\'t write ISOs without structured folders: [gold1]--isos[/gold1] option ignored.\n')
+        asked_ISOs = False
+    # output_dir = args.o
+    # if args.verbose_output or args.terse: # verbose, so no progress bars
+    print('Merging...')
+    for merger in matcher.mergers:
+        merger.build_audio_and_write_merged_media(top_dir,
+        False, # args.dont_write_cam_folder,
+        asked_ISOs,
+        audio_REC_only)
+    if not args.terse:
+        print("\n")
+    # find out where files were written
+    # a_merger = matcher.mergers[0]
+    # log file
+    p = Path(platformdirs.user_data_dir('mamsync', 'plutz'))/LOG_FILE
+    log_filehandle = open(p, 'a')
+    for merger in matcher.mergers:
+        print('[gold1]%s[/gold1]'%merger.videoclip.AVpath.name, end='')
+        for audio in merger.get_matched_audio_recs():
+            print(' + [gold1]%s[/gold1]'%audio.AVpath.name, end='')
+        new_file = merger.videoclip.final_synced_file.parts
+        final_p = merger.videoclip.final_synced_file
+        nameAnd2Parents = Path('').joinpath(*final_p.parts[-2:])
+        print(' became [gold1]%s[/gold1]'%nameAnd2Parents)
+        # add full path to log file
+        log_filehandle.write(f'{merger.videoclip.AVpath}\n')
+        # matcher._build_otio_tracks_for_cam()
+    log_filehandle.close()
+    matcher.set_up_clusters() # multicam
+    matcher.shrink_gaps_between_takes(args.timelineoffset)
+    logger.debug('matcher.multicam_clips_clusters %s'%
+                        pformat(matcher.multicam_clips_clusters))
+    # clusters is list of {'end': t1, 'start': t2, 'vids': [r1,r3]}
+    # really_clusters is True if one of them has len() > 1
+    really_clusters = any([len(cl['vids']) > 1 for cl
+                        in matcher.multicam_clips_clusters])
+    if really_clusters:
+        if scanner.input_structure == 'loose':
+            print('\nThere are synced multicam clips but without structured folders')
+            print('they were not grouped together under the same folder.')
+        else:
+            matcher.move_multicam_to_dir()
+    else:
+        logger.debug('not really a multicam cluster, nothing to move')
+    sys.exit(0)
+    
+if __name__ == '__main__':
+    main()
+
+
+

{tictacsync-1.0.0a0 → tictacsync-1.0.2a0}/tictacsync/multi2polywav.py

@@ -31,7 +31,7 @@ def print_grby(grby):
 def wav_recursive_scan(top_directory):
     files_lower_case = Path(top_directory).rglob('*.wav') 
     files_upper_case = Path(top_directory).rglob('*.WAV')
-    files = list(files_lower_case) + list(files_upper_case)
+    files = set(list(files_lower_case) + list(files_upper_case))
     paths = [
         p
         for p in files

{tictacsync-1.0.0a0 → tictacsync-1.0.2a0}/tictacsync/newmix.py

@@ -97,7 +97,7 @@ def parse_and_check_arguments():
     parser.add_argument('-b',
                     nargs=1,
                     dest='both_audio_vid',
-                    help='Directory scanned for both audio and video')
+                    help='Directory scanned for both audio and video, when tictacsync was used in "alongside mode"')
     parser.add_argument('--dry',
                     action='store_true',
                     dest='scan_only',
@@ -133,6 +133,9 @@ def parse_and_check_arguments():
     #     parser.print_help(sys.stderr)
     #     sys.exit(0)
     # list of singletons, so flatten. Keep None and False as is
+    if args.scan_only:
+        print('Sorry, --dry option not implemented yet, bye.')
+        sys.exit(0)
     return args
 
 def get_recent_mix(SND_dir, vid):

{tictacsync-1.0.0a0 → tictacsync-1.0.2a0/tictacsync.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: tictacsync
-Version: 1.0.0a0
+Version: 1.0.2a0
 Summary: command for syncing audio video recordings
 Home-page: https://tictacsync.org/
 Author: Raymond Lutz
@@ -58,7 +58,7 @@ Then pip install the syncing program:
 This should install python dependencies _and_ the `tictacsync` command.
 ## Usage
 
-Download multiple sample files [here](https://nuage.lutz.quebec/s/P3gbZR4GgGy8xQp/download/dailies1_1.zip) (625 MB, sorry) unzip and run:
+Download multiple sample files [here](https://nuage.lutz.quebec/s/D4DgzHrLaAjqNmY) (625 MB, sorry) unzip and run:
 
     > tictacsync dailies/loose
 The program `tictacsync` will recursively scan the directory given as argument, find all audio that coincide with any video and merge them into a subfolder named `SyncedMedia`. When the argument is an unique media file (not a directory), no syncing will occur but the decoded starting time will be printed to stdout:

{tictacsync-1.0.0a0 → tictacsync-1.0.2a0}/tictacsync.egg-info/SOURCES.txt

@@ -4,6 +4,7 @@ setup.py
 tictacsync/__init__.py
 tictacsync/device_scanner.py
 tictacsync/entry.py
+tictacsync/mamsync.py
 tictacsync/multi2polywav.py
 tictacsync/newmix.py
 tictacsync/remergemix.py