tictacsync 0.97a0__py3-none-any.whl → 0.98a0__py3-none-any.whl

tictacsync/entry.py

@@ -1,4 +1,3 @@
-print('Loading modules...', end='')
 
 # I know, the following is ugly, but I need those try's to
 # run the command in my dev setting AND from
@@ -16,18 +15,18 @@ except:
     import timeline
     import multi2polywav
 
-import argparse, tempfile
+import argparse, tempfile, configparser
 from loguru import logger
 from pathlib import Path
 # import os, sys
-import os, sys, sox
+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
+from pprint import pprint, pformat
 import numpy as np
 
 DEL_TEMP = False
@@ -41,37 +40,22 @@ 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):
-    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_files(medias):
-    # maps Media objects -> Recording objects
-    recordings = []
-    rec_with_TTC = []
-    times = []
-    for m in medias:
-        recordings.append(yaltc.Recording(m))
-    for r in recordings:
-        # print('%s duration %.2fs'%(r.AVpath.name, r.get_duration()))
-        if r.seems_to_have_TicTacCode_at_beginning():
-            rec_with_TTC.append(r)
-    for r in rec_with_TTC:
-        times.append(r.get_start_time())
-    return recordings, rec_with_TTC, times
+# 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
@@ -108,7 +92,7 @@ def process_lag_adjustement(media_object):
     # returns nothing
     lags = media_object.device.tracks.lag_values
     logger.debug('will process %s lags'%[lags])
-    channels = timeline._split_channels(media_object.path)
+    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():
@@ -138,12 +122,67 @@ 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(
                 "path",
                 type=str,
-                nargs=1,
+                nargs='*',
                 help="directory_name or media_file"
                 )
     # parser.add_argument("directory", nargs="?", help="path of media directory")
@@ -152,8 +191,15 @@ def main():
                         action='store_true',  #ie default False
                         dest='verbose_output',
                         help='Set verbose ouput')
-    parser.add_argument('-o', nargs=1,
-                    help='Where to write the SyncedMedia folder [default to "path" ]')
+    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'],
@@ -163,6 +209,14 @@ def main():
                     action='store_true',
                     dest='plotting',
                     help='Produce plots')
+    parser.add_argument('-d',
+                    action='store_true',
+                    dest='dont_write_cam_folder',
+                    help="Even if originals are inside CAM folders, don't put synced clips inside a CAM identified folder")
+    # parser.add_argument('-m',
+    #                 action='store_true',
+    #                 dest='multicam',
+    #                 help='Outputs multicam structure for NLE program (based on Davinci Resolve input processing)')
     parser.add_argument('--isos',
                     action='store_true',
                     dest='write_ISOs',
@@ -182,12 +236,39 @@ def main():
         quit()
     if args.verbose_output:
         logger.add(sys.stderr, level="DEBUG")
+    # logger.add(sys.stdout, filter=lambda r: r["function"] == "move_multicam_to_dir")
+    # logger.add(sys.stdout, filter=lambda r: r["function"] == "_merge_audio_and_video")
+    #
     # logger.add(sys.stdout, filter="__main__")
     # logger.add(sys.stdout, filter="yaltc")
-    # logger.add(sys.stdout, filter=lambda r: r["function"] == "scan_audio_for_each_videoclip")
-    # logger.debug(sys.stdout, filter=lambda r: r["function"] == "main")
-    # logger.add(sys.stdout, filter=lambda r: r["function"] == "_build_and_write_audio")
-    # logger.add(sys.stdout, filter=lambda r: r["function"] == "_build_audio_and_write_video")
+
+    # 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
@@ -197,13 +278,13 @@ def main():
         sys.exit(1)
     # logger.debug('args.o %s'%args.o)
     # print('args.o %s'%args.o)
-    if args.o:
-        arg_out_dir = args.o[0]
-    else:
-        arg_out_dir = None
-    if args.o and not os.path.isdir(arg_out_dir):
-        print('%s is not a directory or doesnt exist.'%arg_out_dir)
-        sys.exit(1)
+    # 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()
@@ -212,12 +293,12 @@ def main():
             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 != 'folder_is_device':
+        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')
@@ -242,12 +323,12 @@ def main():
         # 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 == 'folder_is_device':
-            print('\nDetected structured folders', end='')
-            if scanner.top_dir_has_multicam:
-                print(', multicam')
-            else:
-                print()
+        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:
@@ -269,18 +350,19 @@ def main():
         # 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 recoders %s, same:%s'%(freqs, same))
+        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, times = \
-            process_files(scanner.found_media_files)
+    # recordings, rec_with_TTC = process_files(scanner.found_media_files, args)
+    recordings = [yaltc.Recording(m, do_plots=args.plotting) for m 
+                                            in scanner.found_media_files]
     recordings_with_time =  [
         rec 
-        for rec in rec_with_TTC
+        for rec in recordings
         if rec.get_start_time()
         ]
     if audio_REC_only:
@@ -299,9 +381,8 @@ def main():
         table.add_column("Date\n", justify="center", style='gold1')
         rec_WO_time = [
             rec.AVpath.name
-            for rec in rec_with_TTC
-            if not rec.get_start_time()
-            ]
+            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]
@@ -325,7 +406,13 @@ def main():
         console.print(table)
         print()
     n_devices = scanner.get_devices_number()
-    OUT_struct_for_mcam = scanner.top_dir_has_multicam
+    # 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')
@@ -337,30 +424,45 @@ def main():
             print('\nNothing to sync, bye.\n')
         sys.exit(1)
     asked_ISOs = args.write_ISOs
-    if asked_ISOs and scanner.input_structure != 'folder_is_device':
+    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
+    # output_dir = args.o
     # if args.verbose_output or args.terse: # verbose, so no progress bars
     for merger in matcher.mergers:
-        merger.build_audio_and_write_merged_media(top_dir, arg_out_dir,
-        OUT_struct_for_mcam,
+        merger.build_audio_and_write_merged_media(top_dir,
+        args.dont_write_cam_folder,
         asked_ISOs,
         audio_REC_only)
     if not args.terse:
         print("\n")
-    # find out where files were wrtitten
-    a_merger = matcher.mergers[0]
-    print('\nWrote output in folder [gold1]%s[/gold1]'%(
-            a_merger.synced_clip_dir))
+    # find out where files were written
+    # a_merger = matcher.mergers[0]
     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
-        print(' became [gold1]%s[/gold1]'%merger.videoclip.final_synced_file.name)
+        final_p = merger.videoclip.final_synced_file
+        nameAnd2Parents = Path('').joinpath(*final_p.parts[-2:])
+        print(' became [gold1]%s[/gold1]'%nameAnd2Parents)
         # matcher._build_otio_tracks_for_cam()
+    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__':

tictacsync/remrgmx.py

@@ -1,5 +1,11 @@
-import os, itertools
+import os, itertools, argparse
 from pathlib import Path
+from loguru import logger
+import sys
+from pprint import pformat
+
+logger.level("DEBUG", color="<yellow>")
+
 
 video_extensions = \
 """webm mkv flv flv vob ogv  ogg drc gif gifv mng avi mov 
@@ -14,8 +20,11 @@ def is_video(f):
     name, ext = name_ext
     return ext.lower() in video_extensions
 
-def find_ISO_vids_pairs(top):
-    # top is 
+def find_ISO_vids_pairs_in_dir(top):
+    # look for matching video name and ISO dir name
+    # eg: IMG04.mp4 and IMG04_ISO
+    # returns list of matches
+    # recursively search from 'top' argument
     vids = []
     ISOs = []
     for (root,dirs,files) in os.walk(top, topdown=True):
@@ -24,7 +33,8 @@ def find_ISO_vids_pairs(top):
                 ISOs.append(Path(root)/d)
         for f in files:
             if is_video(f):
-                vids.append(Path(root)/f)        
+                vids.append(Path(root)/f)
+    logger.debug('vids %s ISOs %s'%(vids, ISOs))
     matches = []
     for pair in list(itertools.product(vids, ISOs)):
         # print(pair)
@@ -33,6 +43,78 @@ def find_ISO_vids_pairs(top):
         if vidname == ISO.name[:-4]:
             matches.append(pair)
         # print(vidname, ISO.name[:-4])
+    logger.debug('matches: %s'%pformat(matches))
     return matches
 
-[print( vid, ISO) for vid, ISO in find_ISO_vids_pairs('.')]
+# [print( vid, ISO) for vid, ISO in find_ISO_vids_pairs('.')]
+
+def parse_and_check_arguments():
+    # parses directories from command arguments
+    # check for consistencies and warn user and exits,
+    # if returns, gives:
+    #  proxies_dir, originals_dir, audio_dir, both_audio_vid, scan_only
+    parser = argparse.ArgumentParser()
+    parser.add_argument('-p',
+                    nargs=1,
+                    dest='proxies_dir',
+                    help='Where proxy clips are stored')
+    parser.add_argument('-o',
+                    nargs=1,
+                    dest='originals_dir',
+                    help='Original (non-proxy) clips directory')
+    parser.add_argument('-a',
+                    nargs=1,
+                    dest='audio_dir',
+                    help='Contains newly changed mix files')
+    parser.add_argument('-b',
+                    nargs=1,
+                    dest='both_audio_vid',
+                    help='Directory scanned for both audio and video')
+    parser.add_argument('--dry',
+                    action='store_true',
+                    dest='scan_only',
+                    help="Just display changed audio, don't merge")
+    args = parser.parse_args()
+    logger.debug('args %s'%args)
+    # ok cases:
+    # -p -o -a + no -b
+    # -o -a + no -b
+    args_set = [args.proxies_dir != None,
+                    args.originals_dir != None,
+                    args.audio_dir != None,
+                    args.both_audio_vid != None,
+                    ]
+    p, o, a, b = args_set
+    # check that argument -b (both_audio_vid) is used alone
+    if b and any([o, a, p]):
+        print("\nDon't specify other argument than -b if both audio and video searched in the same directory.\n") 
+        parser.print_help(sys.stderr)
+        sys.exit(0)
+    # check that if proxies (-p) are specified, orginals too (-o)
+    if p and not o:
+        print("\nIf proxies directory is specified, so should originals directory.\n") 
+        parser.print_help(sys.stderr)
+        sys.exit(0)
+    # check that -o and -a are used together
+    if not b and not (o and a):
+        print("\nAt least originals and audio directories must be given (-o and -a) when audio and video are in different dir.\n") 
+        parser.print_help(sys.stderr)
+        sys.exit(0)
+    # work in progress (aug 2025), so limit to -b:
+    if not b :
+        print("\nFor now, only -b argument is supported (a directory scanned for both audio and video) .\n") 
+        parser.print_help(sys.stderr)
+        sys.exit(0)
+    arg_dict = vars(args)
+    # list of singletons, so flatten. Keep None and False as is
+    return [e[0] if isinstance(e, list) else e for e in arg_dict.values() ]
+
+
+
+def main():
+    proxies_dir, originals_dir, audio_dir, both_audio_vid, scan_only = \
+        parse_and_check_arguments()
+    m = find_ISO_vids_pairs_in_dir(both_audio_vid)
+
+if __name__ == '__main__':
+    main()