tictacsync 0.1a14__py3-none-any.whl → 1.4.4b0__py3-none-any.whl

tictacsync/entry.py

@@ -1,42 +1,35 @@
-# 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
 # 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
-except:
-    import yaltc
-try:
     from . import device_scanner
-except:
-    import device_scanner
-try:
     from . import timeline
-except:
-    import timeline
-try:
     from . import multi2polywav
 except:
+    import yaltc
+    import device_scanner
+    import timeline
     import multi2polywav
 
-import argparse
+import argparse, tempfile, configparser
 from loguru import logger
 from pathlib import Path
 # import os, sys
-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
-# import itertools
-# from datetime import timedelta
-
-# print(' done')
+from pprint import pprint, pformat
+import numpy as np
 
+DEL_TEMP = False
 
 av_file_extensions = \
 """MOV webm mkv flv flv vob ogv ogg drc gif gifv mng avi MTS M2TS TS mov qt
@@ -47,146 +40,237 @@ 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_yaltc = []
-    times = []
-    for m in track(medias,
-            description="1/4 Initializing Recording objects:"):
-        # file_alias = 'dummy'
-        recordings.append(yaltc.Recording(m))
-    for r in track(recordings,
-            description="2/4   Checking if files have YaLTC:"):
-        if r.seems_to_have_YaLTC_at_beginning():
-            rec_with_yaltc.append(r)
-    for r in track(rec_with_yaltc,
-            description="3/4            Finding start times:"):
-        times.append(r.get_start_time())
-    return recordings, rec_with_yaltc, times
-
-def process_files(medias):
-    recordings = []
-    rec_with_yaltc = []
-    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_YaLTC_at_beginning():
-            rec_with_yaltc.append(r)
-    for r in rec_with_yaltc:
-        times.append(r.get_start_time())
-    return recordings, rec_with_yaltc, times
-
 def process_single(file, args):
     # argument is a single file
-    m = device_scanner.media_dict_from_path(Path(file))
-    a_rec = yaltc.Recording(m)
-    time = a_rec.get_start_time(plots=args.plotting)
+    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.YaLTC_channel))
+                        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.YaLTC_channel))
+                        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')
-    quit()
+    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):
+        # counter intuitive I know. if a file lags, there's too
+        # much samples at the start:
+        # ..................|.........
+        # .......................|....
+        #          ^  play head ->
+        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 main():
     parser = argparse.ArgumentParser()
     parser.add_argument(
-                "directory",
+                "path",
                 type=str,
                 nargs=1,
-                help="path of media directory"
+                help="directory_name or media_file"
                 )
     # parser.add_argument("directory", nargs="?", help="path of media directory")
     # parser.add_argument('-v', action='store_true')
-    parser.add_argument('-v', action='store_true', default=False,
-                    dest='verbose_output',
-                    help='Set verbose ouput')
-    parser.add_argument('-p', action='store_true', default=False,
+    parser.add_argument('-v',
+                        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('-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)')
+    parser.add_argument('-p',
+                    action='store_true',
                     dest='plotting',
-                    help='Make plots')
-    parser.add_argument('--isos', action='store_true', default=False,
+                    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',
-                    help='Write ISO sound files')
-    parser.add_argument('--nosync', action='store_true',
+                    help='Cut ISO sound files')
+    parser.add_argument('--nosync',
+                    action='store_true',
                     dest='nosync',
-                    help='just scan and decode')
-    parser.add_argument('--terse', action='store_true',
+                    help='Just scan and decode')
+    parser.add_argument('--terse',
+                    action='store_true',
                     dest='terse',
-                    help='terse output')
-    # parser.add_argument('--io', dest='output_structure', type=str, default='loose',
-    #                 help='should be one of: loose [DEFAULT], foldercam')
+                    help='Terse output')
     args = parser.parse_args()
-    # if not args.output_structure in 'loose foldercam reconf'.split():
-    #     print('Unknown --io option value "%s", should be one of: loose [DEFAULT] or foldercam'%args.output_structure)
-    #     quit()
+    # print(args)
+    if len(args.timelineoffset) != 1:
+        print('--timelineoffset needs one value, got %s'%args.timelineoffset)
+        quit()
     if args.verbose_output:
         logger.add(sys.stderr, level="DEBUG")
-    # logger.add(sys.stdout, filter="__main__")
-    # logger.add(sys.stdout, filter="device_scanner")
-    # logger.add(sys.stdout, filter="yaltc")
-    # logger.add(sys.stdout, filter="timeline")
-    # logger.add(sys.stdout, filter=lambda r: r["function"] == "_enforce_folder_is_device")
-    # logger.add(sys.stdout, filter=lambda r: r["function"] == "build_audio_and_write_video")
-    # logger.add(sys.stdout, filter=lambda r: r["function"] == "_get_BFSK_word_boundaries")
-    top_dir = args.directory[0]
+
+    # logger.add(sys.stdout, filter=lambda r: r["function"] == "move_multicam_to_dir")
+    # logger.add(sys.stdout, filter=lambda r: r["function"] == "_build_audio_and_write_video")
+    # logger.add(sys.stdout, filter=lambda r: r["function"] == "main")
+    # logger.add(sys.stdout, filter=lambda r: r["function"] == "_build_from_tracks_txt")
+    # logger.add(sys.stdout, filter=lambda r: r["function"] == "scan_media_and_build_devices_UID")
+
+    top_dir = args.path[0]
     if os.path.isfile(top_dir):
         file = top_dir
         process_single(file, args)
     if not os.path.isdir(top_dir):
         print('%s is not a directory or doesnt exist.'%top_dir)
-        quit()
+        sys.exit(1)
     multi2polywav.poly_all(top_dir)
     scanner = device_scanner.Scanner(top_dir, stay_silent=args.terse)
-    # (Path(top_dir)/Path('tictacsynced')).mkdir(exist_ok=True)
-    # scanner.cluster_media_files_by_name()
-    scanner.scan_media_and_build_devices_UID(recursive=False)
+    scanner.scan_media_and_build_devices_UID()
+    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))
+        ref_device = list(devices)[3 - 1]
+        print('When only audio recordings are present, ISOs files will be cut and written.')
     if not args.terse:
-        print('\n\nFound [gold1]%i[/gold1] media files from [gold1]%i[/gold1] devices'%(
-            len(scanner.found_media_files),
-            scanner.get_devices_number()), end='')
-        print('\nThese recordings will be analysed for timestamps:\n')
-        for m in (scanner.found_media_files):
-            print('   ', '[gold1]%s[/gold1]'%m['path'].name)
+        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()
-    if args.verbose_output or args.terse: # verbose or terse, so no progress bars
-        rez = process_files(scanner.found_media_files)
-    else: 
-        rez = process_files_with_progress_bars(scanner.found_media_files)
-    recordings, rec_with_yaltc, times = rez
+    recordings = [yaltc.Recording(m, do_plots=args.plotting) for m 
+                                            in scanner.found_media_files]
     recordings_with_time =  [
         rec 
-        for rec in rec_with_yaltc
+        for rec in recordings
         if rec.get_start_time()
         ]
+    [r.load_track_info() for r in recordings_with_time if r.is_audio()]
+    for r in recordings:
+        # print(f'{r} device: #{id(r.device):x}')
+        logger.debug(f'{r} \nDevice instance id: #{id(r.device):x}')
+        logger.debug(f'device content: {r.device}')
+    if audio_REC_only:
+        for rec in recordings:
+        # print(rec, rec.device == ref_device)
+            if rec.device == ref_device:
+                rec.is_audio_reference = True
     if not args.terse:    
-        print('\n\n')
         table = Table(title="tictacsync results")
         table.add_column("Recording\n", justify="center", style='gold1')
-        table.add_column("YaLTC\nChannel", 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("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 rec_with_yaltc
-            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]
@@ -198,61 +282,82 @@ def main():
             times_range = start_HHMMSS + ':' + end_MMSS
             table.add_row(
                 str(r.AVpath.name),
-                str(r.YaLTC_channel),
+                str(r.TicTacCode_channel),
                 # r.device,
                 times_range,
                 # '%.6f'%(r.true_samplerate/1e3),
                 '%2i'%(r.get_samplerate_drift()),
-                '%.0f'%r.decoder.SN_ratio,
+                # '%.0f'%r.decoder.SN_ratio,
                 date
                 )
         console = Console()
         console.print(table)
-        print('\n')
+        print()
     n_devices = scanner.get_devices_number()
-    OUT_struct_for_mcam = scanner.top_dir_has_multicam
-    # if n_devices > 2:
-    #     print('\nMerging for more than 2 devices is not implemented yet, quitting...')
-    #     quit()
     if len(recordings_with_time) < 2:
         if not args.terse:
             print('\nNothing to sync, exiting.\n')
-        quit()
+        sys.exit(1)
     matcher = timeline.Matcher(recordings_with_time)
-    matcher.scan_audio_for_each_ref_rec()
-    if not matcher.video_mergers:
+    matcher.scan_audio_for_each_videoclip()
+    if not matcher.mergers:
         if not args.terse:
             print('\nNothing to sync, bye.\n')
-        quit()
-    if args.verbose_output or args.terse: # verbose, so no progress bars
-        for stitcher in matcher.video_mergers:
-            stitcher.build_audio_and_write_video(top_dir, OUT_struct_for_mcam,
-                                                    args.write_ISOs)
-    else: 
-        for stitcher in track(matcher.video_mergers,
-            description="4/4         Merging sound to videos:"):
-            stitcher.build_audio_and_write_video(top_dir, OUT_struct_for_mcam,    
-                                                    args.write_ISOs)
+        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,
+    #     args.dont_write_cam_folder,
+    #     asked_ISOs,
+    #     audio_REC_only)
+    for merger in matcher.mergers:
+        if audio_REC_only:
+            # rare
+            merger._build_and_write_audio(top_dir)
+        else:
+            # almost always syncing audio to video clips
+            merger._build_audio_and_write_video(top_dir,
+                args.dont_write_cam_folder, asked_ISOs)
     if not args.terse:
         print("\n")
-    # if args.output_structure == 'foldercam':
-    print('output written in [gold1]%s[/gold1] folder in [gold1]%s[/gold1]\n'%(
-            'SyncedMedia',top_dir))
-    # if args.output_structure == 'loose':
-    for stitcher in matcher.video_mergers:
-        print('[gold1]%s[/gold1]'%stitcher.ref_recording.AVpath.name, end='')
-        for audio in stitcher.get_matched_audio_recs():
+    # 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 = stitcher.ref_recording.final_synced_file.parts
-        print(' became [gold1]%s[/gold1]'%stitcher.ref_recording.final_synced_file.name)
+        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)
         # matcher._build_otio_tracks_for_cam()
-    matcher.shrink_gaps_between_takes()
+    if not audio_REC_only:        
+        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/mamconf.py

@@ -0,0 +1,157 @@
+import argparse, platformdirs, configparser, sys
+from loguru import logger
+from pprint import pformat
+from pathlib import Path
+from rich import print
+
+# [TODO] add in the doc:
+# RAWROOT (sources with TC): "/Users/foobar/movies/MyBigMovie/"
+# SYNCEDROOT (where RAWROOT will be mirrored, but with synced clips): "/Users/foobar/synced"
+# SNDROOT (destination of ISOs sound files): "/Users/foobar/MovieSounds"
+# then
+# "/Users/foobar/synced/MyBigMovie" and "/Users/foobar/MovieSounds/MyBigMovie" will be created
+
+
+CONF_FILE = 'mamsync.cfg'
+LOG_FILE = 'mamdone.txt'
+
+logger.remove()
+# logger.add(sys.stdout, level="DEBUG")
+# logger.add(sys.stdout, filter=lambda r: r["function"] == "write_conf")
+
+
+def print_out_conf(raw_root, synced_root, snd_root, proxies=''):
+    print(f'RAWROOT (sources with TC): "{raw_root}"')
+    print(f'SYNCEDROOT (where RAWROOT will be mirrored, but with synced clips): "{synced_root}"')
+    print(f'SNDROOT (destination of ISOs sound files): "{snd_root}"')
+    if proxies != '':
+        print(f'PROXIES (NLE proxy clips folder): "{proxies}"')
+
+def write_conf(conf_key, conf_val):
+    # 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)
+    current_values = dict(zip(['RAWROOT', 'SYNCEDROOT', 'SNDROOT', 'PROXIES'],
+                        get_proj()))
+    logger.debug(f'old values {current_values}')
+    current_values[conf_key] = conf_val
+    logger.debug(f'updated values {current_values}')
+    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'] = current_values
+    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()}')
+
+def get_proj(print_conf_stdout=False):
+    # check if user started a project before.
+    # stored in platformdirs.user_config_dir
+    # returns a tuple of strings (RAWROOT, SYNCEDROOTS, SNDROOT, PROXIES)
+    # if any, or a tuple of 4 empty strings '' otherwise.
+    # print location of conf file if print_conf_stdout
+    # Note: only raw_root contains the name project
+    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'Will read configuration from file {conf_file}')
+    if conf_file.exists():
+        conf_prs = configparser.ConfigParser()
+        conf_prs.read(conf_file)
+        try:
+            RAWROOT = conf_prs.get('SECTION1', 'RAWROOT')
+        except configparser.NoOptionError:
+            RAWROOT = ''
+        try:
+            SYNCEDROOT = conf_prs.get('SECTION1', 'SYNCEDROOT')
+        except configparser.NoOptionError:
+            SYNCEDROOT = ''
+        try:
+            PROXIES = conf_prs.get('SECTION1', 'PROXIES')
+        except configparser.NoOptionError:
+            PROXIES = ''
+        try:
+            SNDROOT = conf_prs.get('SECTION1', 'SNDROOT')
+        except configparser.NoOptionError:
+            SNDROOT = ''
+        logger.debug('read from conf: RAWROOT= %s SYNCEDROOT= %s SNDROOT=%s PROXIES=%s'%
+                                    (RAWROOT, SYNCEDROOT, SNDROOT, PROXIES))
+        return RAWROOT, SYNCEDROOT, SNDROOT, PROXIES
+    else:
+        logger.debug(f'no config file found at {conf_file}')
+        print('No configuration found.')
+        return '', '', '', ''
+
+def new_parser():
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--rr',
+                        nargs = 1,
+                        dest='rawroot',
+                        help='Sets new value for raw root folder (i.e.: clips with TC)')
+    parser.add_argument('--sr',
+                        nargs = 1,
+                        dest='syncedroot',
+                        help="""Sets where the synced files will be written, to be used by the NLE. Will contain a mirror copy of RAWROOT """)
+    parser.add_argument('--pr',
+                        nargs = 1,
+                        dest='proxies',
+                        help='Sets where the proxy files are stored by the NLE')
+    parser.add_argument('--sf',
+                        nargs = 1,
+                        dest='sndfolder',
+                        help='Sets value for sound folder (will contain a mirror copy of RAWROOT, but with ISO files only)')
+    parser.add_argument('--clearconf',
+                    action='store_true',
+                    dest='clearconf',
+                    help='Clear configured values.')
+    parser.add_argument('--showconf',
+                    action='store_true',
+                    dest='showconf',
+                    help='Show current configured values.')
+    return parser
+
+def main():
+    parser = new_parser()
+    args = parser.parse_args()
+    logger.debug(f'arguments from argparse {args}')
+    if args.rawroot:
+        val = args.rawroot[0]
+        write_conf('RAWROOT', val)
+        print(f'Set source folder of unsynced clips (rawroot) to:\n{val}')
+        sys.exit(0)
+    if args.syncedroot:
+        val = args.syncedroot[0]
+        write_conf('SYNCEDROOT', args.syncedroot[0])
+        print(f'Set destination folder of synced clips (syncedroot) to:\n{val}')
+        sys.exit(0)
+    if args.proxies:
+        val = args.proxies[0]
+        write_conf('PROXIES', args.proxies[0])
+        print(f'Set proxies folder to:\n{val}')
+        sys.exit(0)
+    if args.sndfolder:
+        val = args.sndfolder[0]
+        write_conf('SNDROOT', args.sndfolder[0])
+        print(f'Set destination folder of ISOs sound files (sndfolder) to:\n{val}')
+        sys.exit(0)
+    if args.clearconf:
+        write_conf('RAWROOT', '')
+        write_conf('SYNCEDROOT', '')
+        write_conf('SNDROOT', '')
+        write_conf('PROXIES', '')
+        print_out_conf('','','','')
+        sys.exit(0)
+    if args.showconf:
+        get_proj()
+        print_out_conf(*get_proj(True))
+        sys.exit(0)
+
+if __name__ == '__main__':
+    main()