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

tictacsync/remergemix.py

@@ -1,259 +0,0 @@
-import argparse, wave, subprocess
-from loguru import logger
-from pathlib import Path
-import sox, tempfile, os, ffmpeg
-from rich import print
-import shutil, sys, re
-from pprint import pformat 
-from itertools import groupby
-
-try:
-    from . import timeline
-except:
-    import timeline
-
-DEL_TEMP = False
-
-logger.level("DEBUG", color="<yellow>")
-logger.remove()
-
-# logger.add(sys.stdout, filter=lambda r: r["function"] == "_get_ISO_dirs")
-# logger.add(sys.stdout, filter=lambda r: r["function"] == "_join_audio2video")
-# logger.add(sys.stdout, filter=lambda r: r["function"] == "main")
-# logger.add(sys.stdout, filter="__main__")
-
-OUT_DIR = 'SyncedMedia'
-SEC_DELAY_CHANGED_ISO = 10 #sec, ISO_DIR changed if diff time is bigger
-
-video_extensions = \
-"""webm mkv flv flv vob ogv  ogg drc gif gifv mng avi mov 
-qt wmv yuv rm rmvb viv asf  mp4  m4p m4v mpg  mp2  mpeg  mpe 
-mpv mpg  mpeg  m2v m4v svi 3gp 3g2 mxf roq nsv""".split() # from wikipedia
-
-def _pathname(tempfile_or_path) -> str:
-    # utility for obtaining a str from different filesystem objects
-    if isinstance(tempfile_or_path, str):
-        return tempfile_or_path
-    if isinstance(tempfile_or_path, Path):
-        return str(tempfile_or_path)
-    if isinstance(tempfile_or_path, tempfile._TemporaryFileWrapper):
-        return tempfile_or_path.name
-    else:
-        raise Exception('%s should be Path or tempfile...'%tempfile_or_path)
-
-def _keep_VIDEO_only(video_path):
-    # return file handle to a temp video file formed from the video_path
-    # stripped of its sound
-    in1 = ffmpeg.input(_pathname(video_path))
-    video_extension = video_path.suffix
-    silenced_opts = ["-loglevel", "quiet", "-nostats", "-hide_banner"]
-    file_handle = tempfile.NamedTemporaryFile(suffix=video_extension,
-        delete=DEL_TEMP)
-    out1 = in1.output(file_handle.name, map='0:v', vcodec='copy')
-    ffmpeg.run([out1.global_args(*silenced_opts)], overwrite_output=True)
-    return file_handle
-
-def _join_audio2video(audio_path: Path, video: Path):
-    """
-    Replace audio in video (argument)  by the audio contained in
-    audio_path (argument) returns nothing
-    """
-    video_ext = video.name.split('.')[1]
-    vid_only_handle = _keep_VIDEO_only(video)
-    a_n = _pathname(audio_path)
-    v_n = _pathname(vid_only_handle)
-    out_n = _pathname(video)
-    # building args for debug purpose only:
-    ffmpeg_args = (
-        ffmpeg
-        .input(v_n)
-        .output(out_n, vcodec='copy')
-        # .output(out_n, shortest=None, vcodec='copy')
-        .global_args('-i', a_n, "-hide_banner")
-        .overwrite_output()
-        .get_args()
-    )
-    logger.debug('ffmpeg args: %s'%' '.join(ffmpeg_args))
-    try: # for real now
-        _, out = (
-        ffmpeg
-        .input(v_n)
-        # .output(out_n, shortest=None, vcodec='copy')
-        .output(out_n, vcodec='copy')
-        .global_args('-i', a_n, "-hide_banner")
-        .overwrite_output()
-        .run(capture_stderr=True)
-        )
-        logger.debug('ffmpeg output')
-        for l in out.decode("utf-8").split('\n'):
-            logger.debug(l)
-    except ffmpeg.Error as e:
-        print('ffmpeg.run error merging: \n\t %s + %s = %s\n'%(
-            audio_path,
-            video_path,
-            synced_clip_file
-            ))
-        print(e)
-        print(e.stderr.decode('UTF-8'))
-        sys.exit(1)
-
-def _changed(dir) -> bool:
-    """
-    Returns True if any content of dir (arg) is more recent than dir itself by a
-    delay of SEC_DELAY_CHANGED_ISO. Uses modification times.
-    """
-    logger.debug(f'checking {dir.name} for change')
-    ISO_modification_time = biggest_mtime_in_dir(dir)
-    clip = clip_from_iso(dir)
-    clip_mod_time = clip.stat().st_mtime
-    # difference of modification time in secs
-    ISO_more_recent_by = ISO_modification_time - clip_mod_time
-    logger.debug('ISO_more_recent_by: %s'%(ISO_more_recent_by))
-    iso_edited = ISO_more_recent_by > SEC_DELAY_CHANGED_ISO
-    logger.debug(f'_changed: {iso_edited}')
-    return iso_edited
-
-def sox_mix(ISOdir):
-    """
-    Mixes all wav files present in ISOdir (so excludes ttc file and nullified
-    ones).
-    Returns a mono or stereo tempfile
-    """
-    logger.debug(f'mixing {ISOdir}')
-    def is_stereo_mic(p):
-        re_result = re.match(r'mic([lrLR])*', p.name)
-        # logger.debug(f're_result {re_result}')
-        return re_result is not None
-    stereo_mics = [p for p in ISOdir.iterdir() if is_stereo_mic(p)]
-    monofiles = [p for p in ISOdir.iterdir() if p not in stereo_mics]
-    # removing ttc files
-    def notTTC(p):
-        return p.name[:3] != 'ttc'
-    monofiles = [p for p in monofiles if notTTC(p)]
-    if stereo_mics == []: # mono
-        return timeline._sox_mix_files(monofiles) #-----------------------------
-    logger.debug(f'stereo_mics: {stereo_mics}')
-    def mic(p):
-        return re.search(r'(mic\d*)([lrLR])*', p.name).groups()
-    mics = [mic(p) for p in stereo_mics]
-    p_and_mic = list(zip(stereo_mics, mics))
-    logger.debug(f'p_and_mic: {p_and_mic}')
-    same_mic_key = lambda pair: pair[1][0]
-    p_and_mic = sorted(p_and_mic, key=same_mic_key)
-    grouped_by_mic = [ (k, list(iterator)) for k, iterator
-            in groupby(p_and_mic, same_mic_key)]
-    logger.debug(f'grouped_by_mic: {grouped_by_mic}')
-    def order_left_right(groupby_element):
-        # returns left and right path for a mic
-        name, paths = groupby_element
-        def chan(pair):
-            # (PosixPath('mic1r_ZOOM.wav'), ('mic1', 'r')) -> 'r'
-            return pair[1][1]
-        path_n_mic = sorted(paths, key=lambda pair: pair[1][1])
-        return [p[0] for p in path_n_mic] # just the path, not  ('mic1', 'r')
-    left_right_paths = [order_left_right(e) for e in grouped_by_mic]
-    # logger.debug(f'left_right_paths: {left_right_paths}')
-    stereo_files = [timeline._sox_combine(pair) for pair in left_right_paths]
-    monoNstereo = monofiles + stereo_files
-    return timeline._sox_mix_files(monoNstereo)
-
-def get_mix_file(iso_dir):
-    """
-    If iso_dir (arg) contains a mono mix sound file or a stereo mix, returns its
-    path. If not, this creates the mix and returns it. 
-    """
-    wav_files = list(iso_dir.iterdir())
-    logger.debug(f'wav_files {wav_files}')
-    def is_mix(p):
-        re_result = re.match(r'mix([lrLR])*', p.name)
-        # logger.debug(f're_result {re_result}')
-        return re_result is not None
-    location_mix = [p for p in wav_files if is_mix(p)]
-    if location_mix == []:
-        logger.debug('no mix track, do the mix')
-        return sox_mix(iso_dir)
-    else:
-        return location_mix
-
-def biggest_mtime_in_dir(folder: Path) -> float:
-    # return the most recent mod time of the files in a folder
-    dir_content = list(folder.iterdir())
-    stats = [p.stat() for p in dir_content]
-    mtimes = [stat.st_mtime for stat in stats]
-    return max(mtimes)
-
-def clip_from_iso(ISO_dir: Path) -> Path:
-    # find the sibling video file of ISO_dir. eg : MVI_01.ISO -> MVI_01.MP4
-    folder = ISO_dir.parent
-    siblings = list(folder.glob('%s.*'%ISO_dir.stem))
-    candidates =[p for p in siblings if p.name.split('.')[1] != 'ISO']
-    # should be unique
-    if len(candidates) != 1:
-        print(f'Error finding video corresponding to {ISO_dir}, quitting')
-        sys.exit(1)
-    return candidates[0]
-
-def _get_ISO_dirs(top_dir):
-    """
-    Check if top_dir contains (or somewhere beneath) videos with their
-    accompanying ISO folder (like the pair MVI_023.MP4 + MVI_023.ISO). If not
-    warns and exits.
-
-    Returns list of paths pointing to ISO dirs.
-    """
-    p = Path(top_dir)
-    ISO_dirs = list(Path(top_dir).rglob('*.ISO'))
-    logger.debug('all files: %s'%pformat(ISO_dirs))
-    # validation: .ISO should be dir
-    all_are_dir = all([p.is_dir() for p in ISO_dirs])
-    logger.debug('.ISO are all dir %s'%all_are_dir)
-    if not all_are_dir:
-        print('Error: some .ISO are not folders??? Quitting. %s'%ISO_dirs)
-        sys.exit(1)
-    # for each folder check a video file exists with the same stem
-    # but with a video format extension (listed in video_extensions)
-    for ISO in ISO_dirs:
-        logger.debug(f'checking {ISO}')
-        voisins = list(ISO.parent.glob(f'{ISO.stem}.*'))
-        voisins_suffixes = [p.suffix for p in voisins]
-        # remove ISO
-        voisins_suffixes.remove('.ISO')
-        # validations: should remain one element and should be video
-        suffix = voisins_suffixes[0].lower()[1:] # remove dot
-        logger.debug(f'remaining ext: {suffix}')
-        if len(voisins_suffixes) != 1 or suffix not in video_extensions:
-            print(f'Error with {voisins}, no video unique sibling?')
-            sys.exit(1) #-------------------------------------------------------
-    logger.debug(f'All ok, returning {ISO_dirs}')
-    return ISO_dirs
-
-def main():
-    parser = argparse.ArgumentParser()
-    parser.add_argument(
-                "directory",
-                type=str,
-                nargs=1,
-                help="path of media directory containing Synced videos and their .ISO folder",
-                default='.'
-                )
-    args = parser.parse_args()
-    logger.debug('args %s'%args)
-    ISO_dirs = _get_ISO_dirs(args.directory[0])
-    logger.debug(f'Will check any change in {pformat(ISO_dirs)}')
-    changed_ISOs = [isod for isod in ISO_dirs if _changed(isod)]
-    logger.debug(f'changed_ISOs: {changed_ISOs}')
-    if changed_ISOs != []:
-        print('Will remix audio for:')
-    for p in changed_ISOs:
-        print(p.name)
-    newaudio_and_videos = [(get_mix_file(iso), clip_from_iso(iso)) for iso
-                                                    in changed_ISOs]
-    for audio, video_clip in newaudio_and_videos:
-        print(f'Will remerge {video_clip.name}')
-        _join_audio2video(audio, video_clip)
-    if newaudio_and_videos == []:
-        print('Nothing has changed, bye.')
-    sys.exit(0)
-
-if __name__ == '__main__':
-    main()

tictacsync/remrgmx.py

@@ -1,116 +0,0 @@
-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 
-qt wmv yuv rm rmvb viv asf  mp4  m4p m4v mpg  mp2  mpeg  mpe 
-mpv mpg  mpeg  m2v m4v svi 3gp 3g2 mxf roq nsv""".split() # from wikipedia
-
-def is_video(f):
-    # True if name as video extension
-    name_ext = f.split('.')
-    if len(name_ext) != 2:
-        return False
-    name, ext = name_ext
-    return ext.lower() in video_extensions
-
-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):
-        for d in dirs:
-            if d[-4:] == '_ISO':
-                ISOs.append(Path(root)/d)
-        for f in files:
-            if is_video(f): # add being in SyncedMedia or SyncedMulticamClips folder
-                vids.append(Path(root)/f)
-    logger.debug('vids %s ISOs %s'%(pformat(vids), pformat(ISOs)))
-    matches = []
-    for pair in list(itertools.product(vids, ISOs)):
-        # print(pair)
-        vid, ISO = pair
-        vidname, ext = vid.name.split('.')
-        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('.')]
-
-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('-v',
-                    nargs=*,
-                    dest='video_dirs',
-                    help='Where proxy clips and/or originals are stored')
-    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()

tictacsync/synciso.py

@@ -1,143 +0,0 @@
-import argparse, wave, subprocess
-from loguru import logger
-from pathlib import Path
-import sox, tempfile, os, ffmpeg
-from rich import print
-import shutil
-
-
-logger.remove()
-OUT_DIR = 'SyncedMedia'
-
-def _pathname(tempfile_or_path) -> str:
-    if isinstance(tempfile_or_path, str):
-        return tempfile_or_path
-    if isinstance(tempfile_or_path, Path):
-        return str(tempfile_or_path)
-    if isinstance(tempfile_or_path, tempfile._TemporaryFileWrapper):
-        return tempfile_or_path.name
-    else:
-        raise Exception('%s should be Path or tempfile...'%tempfile_or_path)
-
-def _join(left_right: list, video: Path, out: Path):
-    video_ext = video.name.split('.')[1]
-    audio_left = (
-        ffmpeg
-        .input(_pathname(left_right[0])))
-    audio_right = (
-        ffmpeg
-        .input(_pathname(left_right[1])))
-    input_video = ffmpeg.input(_pathname(video))
-    out_file = tempfile.NamedTemporaryFile(suffix='.%s'%video_ext)
-    try:
-        (ffmpeg
-        .filter((audio_left, audio_right), 'join', inputs=2,
-                    channel_layout='stereo')
-        .output(input_video.video, _pathname(out_file),
-                    shortest=None, vcodec='copy', loglevel="quiet")
-        .overwrite_output()
-        .run())
-    except ffmpeg.Error as e:
-        print(e)
-        print(e.stderr.decode('UTF-8'))
-        quit()
-    shutil.copyfile(_pathname(out_file), _pathname(video))
-
-
-def sync_cam(dir):
-    # dir is a CAM dir, contents are clips and ISO folders
-    ISOs = list(dir.glob('*.ISO'))
-    for iso in ISOs:
-        # iso is a folder
-        statResult = iso.stat()
-        mtime = statResult.st_mtime
-        # print('%s: %s'%(iso.name, biggest_mtime_in_dir(iso)))
-        iso_mod_time = biggest_mtime_in_dir(iso)
-        clip = clip_from_iso(iso)
-        clip_mod_time = clip.stat().st_mtime
-        iso_edited = iso_mod_time > clip_mod_time
-        # print('clip %s should be resync: %s'%(clip.name, iso_edited))
-        # print(clip)
-        if iso_edited:
-            print('Resyncing [gold1]%s[/gold1]'%clip.name)
-            LR_channels = list(valid_audio_files(iso))
-            _join(LR_channels, clip, 'test.MOV')
-
-
-def valid_audio_files(isofolder: Path) -> list:
-    """
-    Returns two valid audio files to be synced with video
-    case A - only two files differing by L and R
-    case B - more than two files, two are mixL mixR
-    case C - one file only -> quit()
-    case D - more than two files, no mixL mixR -> quit()
-    """
-    files = list(isofolder.iterdir())
-    if len(files) == 1: # case C
-        print('Error with folder %s: no mixL.wav, mixR.wav'%isofolder)
-        print('or micL.wav, micR.wav... Quitting.')
-        quit()
-    def _is_case_A(files):
-        if len(files) != 2:
-            return False
-        stems = [p.stem.upper() for p in files]
-        lasts = [st[-1] for st in stems]
-        LR_pair = ''.join(lasts) in ['LR', 'RL']
-        prefix = [st[:-1] for st in stems]
-        same = prefix[0] == prefix[1]
-        return same and LR_pair
-    if _is_case_A(files):
-        return files
-    def _is_case_B(files):
-        if len(files) <= 2:
-            return False
-        stems = [p.stem.upper() for p in files]
-        return 'MIXL' in stems and 'MIXR' in stems
-    if _is_case_B(files):
-        return isofolder.glob('mix?.*')
-    print('Error with folder %s: no mixL.wav, mixR.wav'%isofolder)
-    print('or micL.wav, micR.wav... Quitting.')
-    quit()
-
-def biggest_mtime_in_dir(folder: Path) -> float:
-    # return the most recent mod time in a folder
-    dir_content = list(folder.iterdir())
-    stats = [p.stat() for p in dir_content]
-    mtimes = [stat.st_mtime for stat in stats]
-    return max(mtimes)
-
-def clip_from_iso(p: Path) -> Path:
-    folder = p.parent
-    pair = list(folder.glob('%s.*'%p.stem))
-    return [p for p in pair if p.name.split('.')[1] != 'ISO'][0]
-
-def synciso(top_dir):
-    p = Path(top_dir)/OUT_DIR
-    dir_content = list(p.iterdir())
-    logger.debug('dir_content %s'%dir_content)
-    all_are_dir = all([p.is_dir() for p in dir_content])
-    logger.debug('all_are_dir %s'%all_are_dir)
-    if not all_are_dir:
-        print('Error: resync possible only on structured folders,')
-        print('Rerun tictacsync with one directory for each device.')
-        quit()
-    [sync_cam(f) for f in dir_content]
-
-def main():
-    parser = argparse.ArgumentParser()
-    parser.add_argument(
-                "directory",
-                type=str,
-                nargs='+',
-                help="path of media directory containing SyncedMedia/",
-                default='.'
-                )
-    args = parser.parse_args()
-    # logger.info('arguments: %s'%args)
-    logger.debug('args %s'%args)
-    synciso(args.directory)
-        # for e in keylist:
-        #     print(' ', e)
-
-if __name__ == '__main__':
-    main()

tictacsync-1.2.0b0.dist-info/RECORD

@@ -1,19 +0,0 @@
-tictacsync/LTCcheck.py,sha256=IEfpB_ZajWuRTWtqji0H-B2g7GQvWmGVjfT0Icumv7o,15704
-tictacsync/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-tictacsync/device_scanner.py,sha256=ZF4ufRQGUv-6zMFW4fzNZpcFYGr8uUPKRK6jM9_b-P4,36435
-tictacsync/entry.py,sha256=xwqziTH1M1m1-6ZUOVO_B7xht9zRZ22G_6ITBtRsEXE,15911
-tictacsync/mamconf.py,sha256=FCgwsAadFzrhEUHa7IFSA0nBJV1SyKK55iSTAFR5Nwc,6974
-tictacsync/mamsync.py,sha256=2XPhlw2P6IBUoNFUjBhpV4eKP3JqD501zy0iZFXXEjo,16696
-tictacsync/multi2polywav.py,sha256=78W5yzKBfWy4nmD837VKwmcHAUZm10zRNe8ARUBJWCI,7439
-tictacsync/newmix.py,sha256=-zDxr6_O-rjyo1QfgktvHgwqy_un07eFI4zKi8nygIQ,19188
-tictacsync/remergemix.py,sha256=bRyi1hyNcyM1rTkHh8DmSsIQjYpwPprxSyyVipnxz30,9909
-tictacsync/remrgmx.py,sha256=FxaAo5qqynpj6O56ekQGD31YP6X2g-kEdwVpHSCoh4Q,4265
-tictacsync/synciso.py,sha256=XmUcdUF9rl4VdCm7XW4PeYWYWM0vgAY9dC2hapoul9g,4821
-tictacsync/timeline.py,sha256=wcj3n5nAWavJlrZ5Ia-WFmdI2lflU8V1uL13yhrUI7s,75836
-tictacsync/yaltc.py,sha256=1XlOmdz-8ZUKF97A30MEkIA0F5oThqDgWPV8Ik3CHn4,53179
-tictacsync-1.2.0b0.dist-info/LICENSE,sha256=ZAOPXLh1zlQAnhHUd7oLslKM01YZ5UiAu3STYjwIxck,1068
-tictacsync-1.2.0b0.dist-info/METADATA,sha256=SzpJguMsyz9ZRg6uhP7Csw-oa2URSuCNKjj4kWVj66E,5694
-tictacsync-1.2.0b0.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
-tictacsync-1.2.0b0.dist-info/entry_points.txt,sha256=EZrwgJ0nlXDdVUDcMEijMnha5lb1YCkkg4DY9iz97BE,199
-tictacsync-1.2.0b0.dist-info/top_level.txt,sha256=eaCWG-BsYTRR-gLTJbK4RfcaXajr0gjQ6wG97MkGRrg,11
-tictacsync-1.2.0b0.dist-info/RECORD,,