tictacsync 1.2.0b0__py3-none-any.whl → 1.4.0b0__py3-none-any.whl

tictacsync/mamreap.py

@@ -0,0 +1,481 @@
+import json, pathlib, itertools, os, re, ffmpeg, shutil, time
+import argparse, platformdirs, configparser, sys
+from loguru import logger
+from pprint import pformat
+from dataclasses import dataclass
+from rich import print
+from enum import Enum
+from rich.progress import Progress
+
+# send-to-sound DSC085 -> one clip only, find the ISOs, load the clip
+# send-to-sound cut27.otio -> whole project
+# send-to-sound cut27.otio cut27.mov
+#     cut27.mov has TC + duration -> can find clips in otio...
+#     place cut27.mov according to its TC
+#     produce a cut27mix.wav saved in SNDROOT/postprod
+# three modes: one clip; some clips; all clips
+
+
+
+try:
+    from . import mamconf
+    from . import mamdav
+except:
+    import mamconf
+    import mamdav
+
+dev = 'Cockos Incorporated'
+app ='REAPER'
+REAPER_SCRIPT_LOCATION = pathlib.Path(platformdirs.user_data_dir(app, dev)) / 'Scripts' / 'Atomic'
+REAPER_LUA_CODE = """reaper.Main_OnCommand(40577, 0) -- lock left/right move
+reaper.Main_OnCommand(40569, 0) -- lock enabled
+local function placeWavsBeginingAtTrack(clip, start_idx)
+  for i, file in ipairs(clip.files) do
+    local track_idx = start_idx + i - 1
+    local track = reaper.GetTrack(nil,track_idx-1)
+    reaper.SetOnlyTrackSelected(track)
+    local left_trim = clip.in_time - clip.start_time
+    local where = clip.timeline_pos - left_trim
+    reaper.SetEditCurPos(where, false, false)
+    reaper.InsertMedia(file, 0 )
+    local item_cnt = reaper.CountTrackMediaItems( track )
+    local item = reaper.GetTrackMediaItem( track, item_cnt-1 )
+    local take = reaper.GetTake(item, 0)
+    -- reaper.GetSetMediaItemTakeInfo_String(take, "P_NAME", clip.name, true)
+    local pos = reaper.GetMediaItemInfo_Value(item, "D_POSITION")
+    reaper.BR_SetItemEdges(item, clip.timeline_pos, clip.timeline_pos + clip.cut_duration)
+    reaper.SetMediaItemInfo_Value(item, "C_LOCK", 2)
+  end
+end
+
+--cut here--
+
+sample of the clips nested table (this will be discarded)
+each clip has an EDL info table plus a sequence of ISO files:
+
+clips =
+{
+{
+    name="canon24fps01.MOV", start_time=7.25, in_time=21.125, cut_duration=6.875, timeline_pos=3600,
+    files=
+        {
+        "/Users/lutzray/Downloads/SoundForMyMovie/MyBigMovie/day01/leftCAM/card01/canon24fps01_SND/ISOfiles/Alice_canon24fps01.wav",
+        "/Users/lutzray/Downloads/SoundForMyMovie/MyBigMovie/day01/leftCAM/card01/canon24fps01_SND/ISOfiles/Bob_canon24fps01.wav"
+        }
+},
+{name="DSC_8063.MOV", start_time=0.0, in_time=5.0, cut_duration=20.25, timeline_pos=3606.875,
+files={"/Users/lutzray/Downloads/SoundForMyMovie/MyBigMovie/day01/rightCAM/ROLL01/DSC_8063_SND/ISOfiles/Alice_DSC_8063.wav",
+"/Users/lutzray/Downloads/SoundForMyMovie/MyBigMovie/day01/rightCAM/ROLL01/DSC_8063_SND/ISOfiles/Bob_DSC_8063.wav"}},
+{name="canon24fps02.MOV", start_time=35.166666666666664, in_time=35.166666666666664, cut_duration=20.541666666666668, timeline_pos=3627.125, files={"/Users/lutzray/Downloads/SoundForMyMovie/MyBigMovie/day01/leftCAM/card01/canon24fps02_SND/ISOfiles/Alice_canon24fps02.wav",
+"/Users/lutzray/Downloads/SoundForMyMovie/MyBigMovie/day01/leftCAM/card01/canon24fps02_SND/ISOfiles/Bob_canon24fps02.wav"}}
+}
+
+--cut here--
+-- make room fro the tracks to come
+amplitude_top = 0
+amplitude_bottom = 0
+for i_clip, cl in pairs(clips) do
+  if i_clip%2 ~= 1 then
+    amplitude_top = math.max(amplitude_top, #cl.files)
+  else
+    amplitude_bottom = math.max(amplitude_bottom, #cl.files)
+  end
+end
+for i = 1 , amplitude_top + amplitude_bottom + 1 do
+  reaper.InsertTrackAtIndex( -1, false ) -- at end
+end
+track_count = reaper.CountTracks(0)
+-- ISOs will be up and down the base_track index
+base_track = track_count - amplitude_bottom
+for iclip, clip in ipairs(clips) do
+  start_track_number = base_track
+  -- alternating even/odd, odd=below base_track 
+  if iclip%2 == 0 then -- above base_track, start higher
+    start_track_number = base_track - #clip.files
+  end
+  placeWavsBeginingAtTrack(clip, start_track_number)
+  if #clips > 1 then -- interclips editing
+    reaper.AddProjectMarker(0, false, clip.timeline_pos, 0, '', -1)
+  end
+end
+reaper.SetEditCurPos(3600, false, false)
+reaper.Main_OnCommand(40151, 0)
+if #clips > 1 then -- interclips editing
+-- last marker at the end
+  last_clip = clips[#clips]
+  reaper.AddProjectMarker(0, false, last_clip.timeline_pos + last_clip.cut_duration, 0, '', -1)
+end
+
+"""
+v_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""".split()
+
+
+
+logger.level("DEBUG", color="<yellow>")
+logger.add(sys.stdout, level="DEBUG")
+logger.remove()
+
+# class Modes(Enum):
+#     INTRACLIP = 1 # send-to-sound --clip DSC085 -> find the ISOs, load the clip in Reaper
+#     INTERCLIP_SOME = 2 # send-to-sound cut27.otio cut27.mov
+#             # cut27.mov has TC + duration -> can find clips in otio...
+#             # place cut27.mov according to its TC
+#             # Reaper will then produces a cut27mix.wav saved in SNDROOT/postprod
+#     INTERCLIP_ALL = 3 # send-to-sound cut27.otio -> whole project
+
+# logger.add(sys.stdout, filter=lambda r: r["function"] == "parse_args_get_mode")
+def parse_args_get_mode():
+    """
+    parse args and determine which one of modes is used: INTRACLIP, INTERCLIP_SOME or
+    INTERCLIP_ALL.
+    Returns a 4-tuple: (mode, clip_argument, otio_file, render_file);
+    mode is of type mamdav.Modes(Enum); each of clip_argument, otio_file and render_file is None
+    if unset on the command line and of type str if set.
+    """
+
+    descr = """Take the video clip (-c option) or parse the submitted OTIO timeline
+    (-a and -p options) to build a Reaper Script which loads the corresponding
+    ISO files from SNDROOT (see mamconf --show)."""
+    parser = argparse.ArgumentParser(description=descr)
+    parser.add_argument('-e',
+                    action='store_true',
+                    help="exit on completion (don't wait for the wav mix to be rendered by Reaper)")
+    parser.add_argument('-c',
+                    dest='the_clip',
+                    nargs=1,
+                    help="send only this specified clip to Reaper (partial name is OK)")
+    parser.add_argument('-a',
+                    dest='all',
+                    nargs='*',
+                    help="all the timeline will be sent and edited in Reaper")
+    parser.add_argument('-p',
+                    dest='partial',
+                    nargs='*',
+                    help="only a timeline selected region will be edited in Reaper")
+    args = parser.parse_args()
+    logger.debug('args %s'%args)
+    if args.the_clip != None:
+        if len(args.the_clip) > 1:
+            print('Error: -c <A_CLIP> option should be used alone without any other argument. Bye.')
+            sys.exit(0)
+        else:
+            # e.g. send-to-sound DSC087
+            # return: mode, clip_argument, otio_file, render
+            mode, clip_argument, otio_file, render_file = \
+                (mamdav.Modes.INTRACLIP, *args.the_clip, None, None)
+            exit = args.e
+            logger.debug('mode, clip_argument, otio_file, render_file, exit:')
+            logger.debug(f'{str(mode)}, { clip_argument}, {otio_file}, {render_file}, {exit}.')
+            return mode, clip_argument, otio_file, render_file, exit #################
+    def _is_otio(f):
+        components = f.split('.')
+        if len(components) == 1:
+            return False
+        return components[-1].lower() == 'otio'
+    if args.all != None:
+        otio_and_render = args.all
+        if args.partial != None:
+            print('Error: -a and -p are mutually exclusive, bye.')
+            sys.exit(0)
+    if args.partial != None:
+        otio_and_render = args.partial
+        if args.all != None:
+            print('Error: -a and -p are mutually exclusive, bye.')
+            sys.exit(0)
+    if len(otio_and_render) > 2:
+        print(f'Error: no more than two files are needed, bye.')
+        sys.exit(0)
+    otio_candidate = [f for f in otio_and_render if _is_otio(f)]
+    logger.debug(f'otio_candidate {otio_candidate}')
+    if len(otio_candidate) == 0:
+        print('Error: an OTIO file (or a -c argument) is needed. Bye.')
+        sys.exit(0)
+    if len(otio_candidate) > 1:
+        print(f'Error: one OTIO file is needed, not {len(otio_candidate)}. Bye.')
+        sys.exit(0)
+    otio = otio_candidate[0]
+    if len(otio_and_render) == 1:
+        # e.g.: send-to-sound cut27.otio
+        # return: mode, clip_argument, otio_file, render
+        mode, clip_argument, otio_file, render_file = \
+            (mamdav.Modes.INTERCLIP_ALL, None, otio, None)
+        exit = args.e
+        logger.debug('mode, clip_argument, otio_file, render_file, exit:')
+        logger.debug(f'{str(mode)}, { clip_argument}, {otio_file}, {render_file}, {exit}.')
+        return mode, clip_argument, otio_file, render_file, exit #####################
+    render = [f for f in otio_and_render if f != otio][0]
+    if render.split('.')[-1].lower() not in v_file_extensions:
+        print(f'Error: "{render}" does not have a video file extension, bye.')
+        sys.exit(0)
+    # e.g.: send-to-sound cut27.otio cut27.mov
+    # return: mode, clip_argument, otio_file, render
+    mode, clip_argument, otio_file, render_file = \
+        (mamdav.Modes.INTERCLIP_SOME, None, otio, render)
+    exit = args.e
+    logger.debug('mode, clip_argument, otio_file, render_file, exit:')
+    logger.debug(f'{str(mode)}, { clip_argument}, {otio_file}, {render_file}, {exit}.')
+    return mode, clip_argument, otio_file, render_file, exit #########################
+
+@dataclass
+class Clip:
+    # all time in seconds
+    start_time: float # the start time of the clip, != 0 if metadata TC
+    in_time: float # time of 'in' point, if in_time == start_time, no left trim
+    cut_duration: float # with this value, right trim is detemined, if needed
+    whole_duration: float # unedited clip duration
+    name: str #
+    path: str # path of clip
+    timeline_pos: float # when on the timeline the clip starts
+    ISOdir: None # folder of ISO files for clip
+
+def clip_info_from_json(jsoncl):
+    """
+    parse data from an OTIO json Clip
+    https://opentimelineio.readthedocs.io/en/latest/tutorials/otio-serialized-schema.html#clip-2
+    returns a list composed of (all times are in seconds):
+        st, start time (from clip metadata TC) 
+        In, the "in time", if in_time == start_time, no left trim
+        cd, the cut duration
+        wl, the whole length of the unedited clip
+        the clip file path (string)
+        name (string)
+    NB: Clip.timeline_pos (the position on the global timeline) is not set here but latter computed from summing cut times
+    """
+    def _float_time(json_rationaltime):
+        # returns a time in seconds (float)
+        return json_rationaltime['value']/json_rationaltime['rate']
+    av_range = jsoncl['media_references']['DEFAULT_MEDIA']['available_range']
+    src_rg = jsoncl['source_range']
+    st = av_range['start_time']
+    In = src_rg['start_time']
+    cd = src_rg['duration']
+    wl = av_range['duration']
+    path = jsoncl['media_references']['DEFAULT_MEDIA']['target_url']
+    name = jsoncl['media_references']['DEFAULT_MEDIA']['name']
+    return Clip(*[_float_time(t) for t in [st, In, cd, wl,]] + \
+                    [name, path, 0, None])
+
+def get_SND_dirs(snd_root):
+    # returns all directories found under snd_root
+    def _searchDirectory(cwd,searchResults):
+        dirs = os.listdir(cwd)
+        for dir in dirs:
+            fullpath = os.path.join(cwd,dir)
+            if os.path.isdir(fullpath):
+                searchResults.append(fullpath)
+                _searchDirectory(fullpath,searchResults)
+    searchResults = []
+    _searchDirectory(snd_root,searchResults)
+    return searchResults
+
+# logger.add(sys.stdout, filter=lambda r: r["function"] == "find_and_set_ISO_dir")
+def find_and_set_ISO_dir(clip, SND_dirs):
+    """
+    SND_dirs contains all the *_SND directories found in snd_root.
+    This fct finds out which one corresponds to the clip
+    and sets the found path to clip.ISOdir.
+    Returns nothing.
+    """
+    clip_argument = pathlib.Path(clip.path).stem
+    logger.debug(f'clip_argument {clip_argument}')
+    m = re.match(r'(.*)_v(\w{32})', clip_argument) # 
+    logger.debug(f'{clip_argument} match (.*)v([AB]*) { m.groups() if m != None else None}')
+    if m != None:
+        clip_argument = m.groups()[0]
+    # /MyBigMovie/day01/leftCAM/card01/canon24fps01_SND -> canon24fps01_SND
+    names_only = [p.name for p in SND_dirs]
+    logger.debug(f'names-only {pformat(names_only)}')
+    clip_stem_SND = f'{clip_argument}_SND'
+    if clip_stem_SND in names_only:
+        where = names_only.index(clip_stem_SND)
+    else:
+        print(f'Error: OTIO file contains clip not in SYNCEDROOT: {clip_argument} (check with mamconf --show)')
+        sys.exit(0)
+    complete_path = SND_dirs[where]
+    logger.debug(f'found {complete_path}')
+    clip.ISOdir = str(complete_path)
+
+def gen_lua_table(clips):
+    # returns a string defining a lua nested table
+    # top level: a sequence of clips
+    # a clip has keys: name, start_time, in_time, cut_duration, timeline_pos, files
+    # clip.files is a sequence of ISO wav files
+    def _list_ISO(dir):
+        iso_dir = pathlib.Path(dir)/'ISOfiles'
+        ISOs = [f for f in iso_dir.iterdir() if f.suffix.lower() == '.wav']
+        # ISOs = [f for f in ISOs if f.name[:2] != 'tc'] # no timecode
+        logger.debug(f'ISOs {ISOs}')
+        sequence = '{'
+        for file in ISOs:
+            sequence += f'"{file}",\n'
+        sequence += '}'
+        return sequence
+    lua_clips = '{'
+    for cl in clips:
+        ISOs = _list_ISO(cl.ISOdir)
+        # logger.debug(f'sequence {ISOs}')
+        clip_table = f'{{name="{cl.name}", start_time={cl.start_time}, in_time={cl.in_time}, cut_duration={cl.cut_duration}, timeline_pos={cl.timeline_pos}, files={ISOs}}}'
+        lua_clips += f'{clip_table},\n'
+        logger.debug(f'clip_table {clip_table}')
+    lua_clips += '}'
+    return lua_clips
+    
+# logger.add(sys.stdout, filter=lambda r: r["function"] == "read_OTIO_file")
+def read_OTIO_file(f):
+    """
+    returns framerate and a list of Clip instances parsed from
+    the OTIO file passed as (string) argument f;
+    warns and exists if more than one video track.
+    """
+    with open(f) as fh:
+        oti = json.load(fh)
+    video_tracks = [tr for tr in oti['tracks']['children'] if tr['kind'] == 'Video']
+    if len(video_tracks) > 1:
+        print(f"Can only process timeline with one video track, this one has {len(video_tracks)}. Bye.")
+        sys.exit(0)
+    video_track = video_tracks[0]
+    clips = [clip_info_from_json(jscl) for jscl in video_track['children']]
+    # compute each clip global timeline position
+    clip_starts = [0] + list(itertools.accumulate([cl.cut_duration for cl in clips]))[:-1]
+    # Reaper can't handle negative item position (for the trimmed part)
+    # so starts at 1:00:00
+    clip_starts = [t + 3600 for t in clip_starts]
+    logger.debug(f'clip_starts: {clip_starts}')
+    for time, clip in zip(clip_starts, clips):
+        clip.timeline_pos = time
+    logger.debug(f'clips: {pformat(clips)}')
+    return int(oti['global_start_time']['rate']), clips
+
+def build_reaper_render_action(wav_destination):
+    directory = wav_destination.absolute().parent
+    return f"""reaper.GetSetProjectInfo_String(0, "RENDER_FILE","{directory}",true)
+reaper.GetSetProjectInfo_String(0, "RENDER_PATTERN","{wav_destination.name}",true)
+reaper.SNM_SetIntConfigVar("projintmix", 4)
+reaper.Main_OnCommand(40015, 0)
+"""
+# logger.add(sys.stdout, filter=lambda r: r["function"] == "complete_clip_path")
+def complete_clip_path(clip_argument, synced_proj):
+    match = []
+    for (root,dirs,files) in os.walk(synced_proj):
+        for f in files:
+            p = pathlib.Path(root)/f
+            if p.is_symlink() or p.suffix == '.reapeaks':
+                continue
+            # logger.debug(f'{f}')
+            if clip_argument in f.split('.')[0]: # match XYZvA.mov
+                match.append(p)
+    logger.debug(f'matches {match}')
+    if len(match) > 1:
+        print(f'Warning, some filenames collide:')
+        [print(m) for m in match]
+        print('Bye.')
+        sys.exit(0)
+    if len(match) == 0:
+        print(f"Error, didn't find any clip containing *{clip_argument}*. Bye.")
+        sys.exit(0)
+    return match[0]
+
+# logger.add(sys.stdout, filter=lambda r: r["function"] == "main")
+def main():
+    mode, clip_argument, otio_file, render, exit = parse_args_get_mode() 
+    # def _where(a,x):
+    #     # find in which clip time x (in seconds) does fall.
+    #     n = 0
+    #     while n<len(a):
+    #         if a[n].timeline_pos > x:
+    #             break
+    #         else:
+    #             n += 1
+    #     return n-1
+    raw_root, synced_root, snd_root, proxies = mamconf.get_proj(False)
+    proj_name = pathlib.Path(raw_root).stem
+    synced_proj = pathlib.Path(synced_root)/proj_name
+    logger.debug(f'proj_name {proj_name}')
+    logger.debug(f'will search {snd_root} for ISOs')
+    all_SNDROOT_dirs = [pathlib.Path(f) for f in get_SND_dirs(snd_root)]
+    # keep only XYZ_SND dirs
+    SND_dirs = [p for p in all_SNDROOT_dirs if p.name[-4:] == '_SND']
+    logger.debug(f'SND_dirs {pformat(SND_dirs)}')
+    match mode:
+        case mamdav.Modes.INTRACLIP:
+            # e.g.: send-to-sound DSC087
+            logger.debug('Modes.INTRACLIP, intraclip sound edit, clips will have one clip')
+            # traverse synced_root to find clip path
+            clip_path = complete_clip_path(clip_argument, synced_proj)
+            clip_stem = clip_path.stem
+            probe = ffmpeg.probe(clip_path)
+            duration = float(probe['format']['duration'])
+            clips = [Clip(
+                        start_time=0,
+                        in_time=0,
+                        cut_duration=duration,
+                        whole_duration=duration,
+                        name=clip_argument,
+                        path=clip_path,
+                        timeline_pos=3600,
+                        ISOdir='')]
+            [find_and_set_ISO_dir(clip, SND_dirs) for clip in clips]
+            print(f'For video clip: \n{clip_path}\nfound audio in:\n{clips[0].ISOdir}')
+        case mamdav.Modes.INTERCLIP_SOME:
+            # [TODO]
+            # e.g.: mamreap -p cut27.otio cut27.mov
+            pass
+        case mamdav.Modes.INTERCLIP_ALL:
+            # e.g.: send-to-sound cut27.otio
+            logger.debug('Modes.INTERCLIP_ALL, interclip sound edit, filling up ALL clips')
+            _, clips = read_OTIO_file(otio_file)
+            [find_and_set_ISO_dir(clip, SND_dirs) for clip in clips]
+    logger.debug(f'clips with found ISOdir: {pformat(clips)}')
+    lua_clips = gen_lua_table(clips)
+    logger.debug(f'lua_clips {lua_clips}')
+    # title = "Load MyBigMovie Audio.lua" either Modes
+    title = f'Load {pathlib.Path(raw_root).name} Audio'
+    script_path = pathlib.Path(REAPER_SCRIPT_LOCATION)/f'{title}.lua'
+    Lua_script_pre, _ , Lua_script_post = REAPER_LUA_CODE.split('--cut here--')
+    script = Lua_script_pre + 'clips=' + lua_clips + Lua_script_post
+    with open(script_path, 'w') as fh:
+        fh.write(script)
+    print(f'Wrote ReaScripts "{script_path.stem}"', end=' ')
+    if mode == mamdav.Modes.INTRACLIP:
+        render_destination = pathlib.Path(clips[0].ISOdir)/f'{clip_stem}_mix.wav'
+    else:
+        logger.debug('render for mode all clips')
+        op = pathlib.Path(otio_file)
+        render_destination = op.parent/f'{op.stem}_mix.wav'
+        logger.debug(f'render destination {render_destination}')
+    logger.debug(f'will build rendering clip with dest: {render_destination}')
+    lua_code = build_reaper_render_action(render_destination)
+    if render_destination.exists():
+        render_destination.unlink()
+    logger.debug(f'clip\n{lua_code}')
+    script_path = pathlib.Path(REAPER_SCRIPT_LOCATION)/f'Render Movie Audio.lua'
+    with open(script_path, 'w') as fh:
+        fh.write(lua_code)
+    print(f'and "{script_path.stem}"')
+    print(f'Reaper will render audio to "{render_destination.absolute()}"')
+    if mode in [mamdav.Modes.INTERCLIP_ALL, mamdav.Modes.INTERCLIP_SOME]:
+        print(f'Warning: once saved, "{render_destination.name}" wont be of any use if not paired with "{op.name}", so keep them in the same directory.')
+    if not exit:
+        # wait for mix and lauch mamdav
+        print('Go editing in Reaper...')
+        with Progress(transient=True) as progress:
+            task = progress.add_task(f"[green]Waiting for {render_destination.name}...", total=None)
+            while not render_destination.exists():
+                time.sleep(5)
+            progress.stop()
+        time.sleep(3) # finishing writing?
+        print(f'saw {render_destination.name}: ')
+        # print('go mamdav!')
+        wav_path = render_destination
+        movie_path = None
+        otio_path = op
+        mamdav.go(mode, otio_path, movie_path, wav_path)
+
+
+
+if __name__ == '__main__':
+    main()
+

tictacsync/mamsync.py

@@ -10,14 +10,16 @@ try:
     from . import timeline
     from . import multi2polywav
     from . import mamconf
+    from . import entry
 except:
     import yaltc
     import device_scanner
     import timeline
     import multi2polywav
     import mamconf
+    import entry
 
-import argparse, tempfile, configparser
+import argparse, tempfile, configparser, re
 from loguru import logger
 from pathlib import Path
 # import os, sys
@@ -43,75 +45,12 @@ 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.remove()
+logger.level("DEBUG", color="<yellow>")
 # logger.add(sys.stdout, level="DEBUG")
-# logger.add(sys.stdout, filter=lambda r: r["function"] == "main")
+# logger.add(sys.stdout, filter=lambda r: r["function"] == "__init__" and r["module"] == "yaltc")
+# logger.add(sys.stdout, filter=lambda r: r["function"] == "_fit_length")
 # logger.add(sys.stdout, filter=lambda r: r["function"] == "_write_ISOs")
 
-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 copy_to_syncedroot(raw_root, synced_root):
     # args are str
     # copy dirs and non AV files
@@ -123,7 +62,6 @@ def copy_to_syncedroot(raw_root, synced_root):
         if ext not in av_file_extensions and not is_DS_Store:
             logger.debug(f'raw_path: {raw_path}')
             # dont copy WAVs either, they will be in ISOs 
-            # synced_path = Path(synced_root)/str(raw_path)[1:] # cant join abs. paths
             rel = raw_path.relative_to(raw_root)
             logger.debug(f'relative path {rel}')
             synced_path = Path(synced_root)/Path(raw_root).name/rel
@@ -147,6 +85,24 @@ def copy_to_syncedroot(raw_root, synced_root):
                 logger.debug('same content, next')
                 continue # next raw_path in loop
 
+# logger.add(sys.stdout, filter=lambda r: r["function"] == "clean_synced")
+# def clean_synced(raw_root, synced_root):
+#     # removes <>v<capitalLetter>.mov if any
+#     # returns a list of deleted pathlib.Path
+#     project = Path(raw_root).name
+#     logger.debug(f'project {project}')
+#     synced_proj = Path(synced_root)/project
+#     if not synced_proj.exists():
+#         synced_proj.mkdir()
+#     deleted = []
+#     for raw_path in Path(synced_proj).rglob('*'):
+#         m = re.match(r'.*(v[A-Z])\..+', raw_path.name)
+#         if m != None:
+#             logger.debug(f'cleaning {raw_path}')
+#             raw_path.unlink()
+#             deleted.append(raw_path)
+#     return deleted
+
 def copy_raw_root_tree_to_sndroot(raw_root, snd_root):
     # args are str
     # copy only tree structure, no files
@@ -155,8 +111,6 @@ def copy_raw_root_tree_to_sndroot(raw_root, snd_root):
         if raw_path.is_dir():
             synced_path.mkdir(parents=True, exist_ok=True)
 
-
-
 def new_parser():
     parser = argparse.ArgumentParser()
     parser.add_argument('--resync',
@@ -228,6 +182,8 @@ def main():
         top_dir = raw_root
     if args.resync:
         clear_log()
+        # deleted = clean_synced(raw_root, synced_root)
+        # logger.debug(f'deleted older clip versions: {deleted}')
     # go, mamsync!
     copy_to_syncedroot(raw_root, synced_root)
     # copy_raw_root_tree_to_sndroot(raw_root, snd_root) # why?
@@ -240,9 +196,9 @@ def main():
                 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)
+                entry.process_lag_adjustement(m)
     audio_REC_only = all([m.device.dev_type == 'REC' for m
-                                        in scanner.found_media_files])
+                in scanner.found_media_files])
     if not args.terse:
         if scanner.input_structure == 'ordered':
             print('\nDetected structured folders')
@@ -279,12 +235,13 @@ def main():
             quit()
         print()
     recordings = [yaltc.Recording(m, do_plots=False) for m 
-                                            in scanner.found_media_files]
+                        in scanner.found_media_files]
     recordings_with_time =  [
         rec 
         for rec in recordings
         if rec.get_start_time()
         ]
+    [r.load_track_info() for r in recordings_with_time if r.is_audio()]
     if not args.terse:    
         table = Table(title="tictacsync results")
         table.add_column("Recording\n", justify="center", style='gold1')
@@ -333,10 +290,9 @@ def main():
         sys.exit(1)
     if scanner.input_structure != 'ordered':
         print('Warning, can\'t run mamsync without structured folders: [gold1]--isos[/gold1] option ignored.\n')
-    print('Merging...')
     asked_ISOs = True # par defaut
     dont_write_cam_folder = False # write them
-    for merger in matcher.mergers:
+    for merger in track(matcher.mergers, description="Merging..."):
         merger._build_audio_and_write_video(top_dir,
         dont_write_cam_folder,
         asked_ISOs,

tictacsync/multi2polywav.py

@@ -56,7 +56,6 @@ def nframes(path):
         return duration_ts
     return n_frames
 
-
 def build_poly_name(multifiles):
     """
     Returns string of polywav filename, constructed from similitudes between