tictacsync 0.98a0__py3-none-any.whl → 1.4.0b0__py3-none-any.whl

tictacsync/yaltc.py

@@ -15,6 +15,7 @@ logging.config.dictConfig({
     'disable_existing_loggers': True,
 }) # for sox  "output file already exists and will be overwritten on build"
 from datetime import datetime, timezone, timedelta
+from pprint import pformat
 from collections import deque
 from loguru import logger
 from skimage.morphology import closing, erosion, remove_small_objects
@@ -33,6 +34,10 @@ TEENSY_MAX_LAG = 1.01*128/44100 # sec, duration of a default length audio block
 
 # see extract_seems_TicTacCode() for duration criterion values
 
+TRACKSFILE = 'tracks.txt'
+SILENT_TRACK_TOKENS = '-0n'
+
+
 CACHING = True
 DEL_TEMP = False
 MAXDRIFT = 15e-3 # in sec, for end of clip
@@ -68,6 +73,7 @@ BPF_LOW_FRQ, BPF_HIGH_FRQ = (0.5*F1, 2*F2)
 
 # utility for accessing pathnames
 def _pathname(tempfile_or_path):
+    # always returns a str
     if isinstance(tempfile_or_path, type('')):
         return tempfile_or_path ################################################
     if isinstance(tempfile_or_path, Path):
@@ -135,6 +141,34 @@ def to_precision(x,p):
 
     return "".join(out)
 
+def read_audio_data_from_file(file, n_channels):
+    """
+    reads file and returns a numpy.array of shape (N1 channels, N2 samples)
+    where N1 >= 2 (minimaly solo track + TC)
+    """
+    dryrun = (ffmpeg
+        .input(_pathname(file))
+        .output('pipe:', format='s16le', acodec='pcm_s16le')
+        .get_args())
+    dryrun = ' '.join(dryrun)
+    logger.debug('using ffmpeg-python built args to pipe audio stream into numpy array:\nffmpeg %s'%dryrun)
+    try:
+        out, _ = (ffmpeg
+            # .input(str(path), ss=time_where, t=chunk_length)
+            # .input(str(self.AVpath))
+            .input(_pathname(file))
+            .output('pipe:', format='s16le', acodec='pcm_s16le')
+            .global_args("-loglevel", "quiet")
+            .global_args("-nostats")
+            .global_args("-hide_banner")
+            .run(capture_stdout=True))
+        data = np.frombuffer(out, np.int16)
+    except ffmpeg.Error as e:
+        print('error',e.stderr)
+    # transform 1D interleaved channels to [chan1, chan2, chanN]
+    return data.reshape(int(len(data)/n_channels),n_channels).T
+
+
 class Decoder:
     """
     Object encapsulating DSP processes to demodulate TicTacCode track from audio
@@ -188,7 +222,6 @@ class Decoder:
         self.do_plots = do_plots
         self.clear_decoder()
 
-
     def clear_decoder(self):
         self.sound_data_extract = None
         self.pulse_detection_level = None
@@ -524,6 +557,7 @@ class Decoder:
         return int(round(freq_in_hertz))
 
 
+
 class Recording:
     """
     Wrapper for file objects, ffmpeg read operations and fprobe functions
@@ -561,7 +595,7 @@ class Recording:
         sync_position : int
             position of first detected syn pulse
 
-        is_reference : bool (True for ref rec only)
+        is_audio_reference : bool (True for ref rec only)
             in multi recorders set-ups, user decides if a sound-only recording
             is the time reference for all other audio recordings. By
             default any video recording is the time reference for other audio,
@@ -647,7 +681,7 @@ class Recording:
         self.decoder = None
         self.probe = None
         self.TicTacCode_channel = None
-        self.is_reference = False
+        self.is_audio_reference = False
         self.device_relative_speed = 1.0
         # self.valid_sound = None
         self.final_synced_file = None
@@ -688,35 +722,16 @@ class Recording:
             return
         logger.debug('ffprobe found: %s'%self.probe)
         logger.debug('n audio chan: %i'%self.get_audio_channels_nbr())
-        self._read_audio_data()
-
-    def _read_audio_data(self):
-        # sets Recording.audio_data
-        dryrun = (ffmpeg
-            .input(str(self.AVpath))
-            .output('pipe:', format='s16le', acodec='pcm_s16le')
-            .get_args())
-        dryrun = ' '.join(dryrun)
-        logger.debug('using ffmpeg-python built args to pipe audio stream into numpy array:\nffmpeg %s'%dryrun)
-        try:
-            out, _ = (ffmpeg
-                # .input(str(path), ss=time_where, t=chunk_length)
-                .input(str(self.AVpath))
-                .output('pipe:', format='s16le', acodec='pcm_s16le')
-                .global_args("-loglevel", "quiet")
-                .global_args("-nostats")
-                .global_args("-hide_banner")
-                .run(capture_stdout=True))
-            data = np.frombuffer(out, np.int16)
-        except ffmpeg.Error as e:
-            print('error',e.stderr)
-        n_chan = self.get_audio_channels_nbr()
-        if n_chan == 1 and not self.is_video():
-            logger.error('file is sound mono')
+        # self._read_audio_data()
+        N = self.get_audio_channels_nbr()
+        data = read_audio_data_from_file(self.AVpath, n_channels=N)
+        if len(data) == 1 and not self.is_video():
+            print(f'file sound is mono ({self.AVpath}), bye.')
+            sys.exit(0)
         if np.isclose(np.std(data), 0, rtol=1e-2):
-            logger.error("ffmpeg can't extract audio from %s"%self.AVpath)
-        # from 1D  interleaved channels to [chan1, chan2, chanN]
-        self.audio_data = data.reshape(int(len(data)/n_chan),n_chan).T
+            logger.error("ffmpeg can't extract audio from %s"%file)
+            sys.exit(0)
+        self.audio_data = data
         logger.debug('Recording.audio_data: %s of shape %s'%(self.audio_data,
             self.audio_data.shape))
 
@@ -1029,6 +1044,319 @@ class Recording:
         #     self.valid_sound = self.AVpath
         return start_UTC
 
+    def _find_timed_tracks_(self, tracks_file) -> device_scanner.Tracks:
+        """
+        Look for any ISO 8601 timestamp e.g.: 2007-04-05T14:30Z
+        and choose the right chunk according to Recording.start_time
+        """
+        file=open(tracks_file,"r")
+        whole_txt = file.read()
+        tracks_lines = []
+        for l in whole_txt.splitlines():
+            after_sharp = l.split('#')[0]
+            if len(after_sharp) > 0:
+                tracks_lines.append(after_sharp)
+        logger.debug('file %s filtered lines:\n%s'%(tracks_file,
+                                pformat(tracks_lines)))
+        def _seems_timestamp(line):
+            # will validate format later with datetime.fromisoformat()
+            m = re.match(r'ts=(.*)', line)
+            # m = re.match(r'\d{4}-\d{2}-\d{2}T\d{2}:\d{2}Z', line)
+            if m != None:
+                return m.groups()[0]
+            else:
+                return None
+        chunks = []
+        new_chunk = []
+        timestamps_str = []
+        for line in tracks_lines:
+            timestamp_candidate = _seems_timestamp(line)
+            if timestamp_candidate != None:
+                logger.debug(f'timestamp: {line}')
+                timestamps_str.append(timestamp_candidate)
+                chunks.append(new_chunk)
+                new_chunk = []
+            else:
+                new_chunk.append(line)
+        chunks.append(new_chunk)
+        logger.debug(f'chunks {chunks}, timestamps_str {timestamps_str}')
+        str_frmt = '%Y-%m-%dT%H:%MZ'
+        # from strings to datetime instances
+        timestamps = []
+        for dtstr in timestamps_str:
+            try:
+                ts = datetime.fromisoformat(dtstr)
+            except:
+                print(f'Error: in file {tracks_file},\ntimestamp {dtstr} is ill formatted, bye.')
+                sys.exit(0)
+            timestamps.append(ts)
+        # timestamps = [datetime.strptime(dtstr, str_frmt, tzinfo=timezone.utc)
+        #                         for dtstr in timestamps]
+        logger.debug(f'datetime timestamps {timestamps}')
+        # input validations, check order:
+        if sorted(timestamps) != timestamps:
+            print(f'Error in {tracks_file}\nSome timestamps are not in ascending order:\n')
+            multi_lines = "\n".join(tracks_lines)
+            print(f'{multi_lines}, Bye.')
+            sys.exit(0)
+        time_ranges = [t2-t1 for t1,t2 in zip(timestamps, timestamps[1:])]
+        logger.debug(f'time_ranges {time_ranges} ')
+        # check times between timestamps are realistic
+        if timedelta(0) in time_ranges:
+            print(f'Error in {tracks_file}\nSome timestamps are repeating:\n')
+            multi_lines = "\n".join(tracks_lines)
+            print(f'{multi_lines}, Bye.')
+            sys.exit(0)
+        if any([ dt < timedelta(minutes=2) for dt in time_ranges]):
+            print(f'Warning in {tracks_file}\nSome timestamps are spaced by less than 2 minutes:\n')
+            print("\n".join(tracks_lines))
+            print(f'If this is an error, correct and rerun. For now will continue...')
+        if any([ dt > timedelta(days=1) for dt in time_ranges]):
+            print(f'Warning in {tracks_file}\nSome timestamps are spaced by more than 24 hrs:\n')
+            print("\n".join(tracks_lines))
+            print(f'If this is an error, correct and rerun. For now will continue...')
+        # add 'infinite in future' to time stamps for time matching
+        future = datetime.max
+        future = future.replace(tzinfo=timezone.utc)
+        timestamps.append(future)
+        # zip it with chunks
+        timed_chunks = list(zip(chunks,timestamps))
+        logger.debug(f'timed_chunks\n{pformat(timed_chunks)} ')
+        logger.debug(f'will find match with {self.start_time}')
+        # for tch in timed_chunks:
+        #     print(tch[1], self.start_time)
+        #     print(tch[1] > self.start_time)
+        idx = 0
+        # while timed_chunks[idx][1] < self.start_time:
+        #     logger.debug(f'does {timed_chunks[idx][1]} < {self.start_time} ?')
+        #     idx += 1
+        max_idx = len(timed_chunks) - 1
+        while True:
+            if timed_chunks[idx][1] > self.start_time or idx == max_idx:
+                break
+            idx += 1
+        chunk_idx = idx
+        logger.debug(f'chunk_idx {chunk_idx}')
+        right_chunk = chunks[chunk_idx]
+        logger.debug(f'found right chunk {right_chunk}')
+        tracks_instance = self._parse_trx_lines(right_chunk, tracks_file)
+        return tracks_instance
+
+    def _parse_trx_lines(self, tracks_lines_with_spaces, tracks_file):
+        """
+        read track names for naming separated ISOs
+        from tracks_file.
+
+        tokens looked for: mix; mix L; mix R; 0 and TC
+
+        repeating "mic*" pattern signals a stereo track
+        and entries will correspondingly panned into
+        a stero mix named mixL.wav and mixL.wav
+
+        mic L # spaces are ignored |
+        mic R                      | stereo pair
+        micB L
+        micB R
+
+        Returns: a Tracks instance:
+                # track numbers start at 1 for first track (as needed by sox)
+                ttc: int # track number of TicTacCode signal
+                unused: list # of unused tracks
+                stereomics: list # of stereo mics track tuples (Lchan#, Rchan#)
+                mix: list # of mixed tracks, if a pair, order is L than R
+                others: list #of all other tags: (tag, track#) tuples
+                rawtrx: list # list of strings read from file
+                error_msg: str # 'None' if none
+        e.g.: Tracks(   ttc=2,
+                        unused=[],
+                        stereomics=[('mic', (4, 3)), ('mic2', (6, 5))],
+                        mix=[], others=[('clics', 1)],
+                        rawtrx=['clics', 'TC', 'micL', 'micR', 'mic2L;1000', 'mic2R;1000', 'mixL', 'mixR'],
+                        error_msg=None, lag_values=[None, None, None, None, '1000', '1000', None, None])
+        """
+        def _WOspace(chaine):
+            ch = [c for c in chaine if c != ' ']
+            return ''.join(ch)
+        tracks_lines = [_WOspace(l) for l in tracks_lines_with_spaces if len(l) > 0 ]
+        rawtrx = [l for l in tracks_lines_with_spaces if len(l) > 0 ]
+        # add index with tuples, starting at 1
+        logger.debug('tracks_lines whole: %s'%tracks_lines)
+        def _detach_lag_value(line):
+            # look for ";number" ending any line, returns a two-list
+            splt = line.split(';')
+            if len(splt) == 1:
+                splt += [None]
+                if len(splt) != 2:
+                    # error
+                    print('\nText error in %s, line %s has too many ";"'%(
+                            tracks_file, line))
+            return splt
+        tracks_lines, lag_values = zip(*[_detach_lag_value(l) for l 
+                                                    in tracks_lines])
+        lag_values = [e for e in lag_values] # from tuple to list
+        # logger.debug('tracks_lines WO lag: %s'%tracks_lines)
+        tracks_lines = [l.lower() for l in tracks_lines]
+        logger.debug('tracks_lines lower case: %s'%tracks_lines)
+        # print(lag_values)
+        logger.debug('lag_values: %s'%lag_values)
+        tagsWOl_r = [e[:-1] for e in tracks_lines] # skip last letter
+        logger.debug('tags WO LR letter %s'%tagsWOl_r)
+        # find idx of start of pairs
+        # ['clics', 'TC', 'micL', 'micR', 'mic2L', 'mic2R', 'mixL', 'mixR']
+        def _micOrmix(a,b):
+            # test if same and mic mic or mix mix
+            if len(a) == 0:
+                return False
+            return (a == b) and (a in 'micmix')
+        pair_idx_start =[i for i, same in enumerate([_micOrmix(a,b) for a,b
+                        in zip(tagsWOl_r,tagsWOl_r[1:])]) if same]
+        logger.debug('pair_idx_start %s'%pair_idx_start)
+        def LR_OK(idx):
+            # in tracks_lines, check if idx ends a LR pair
+            # delays, if any, have been removed
+            a = tracks_lines[idx][-1]
+            b = tracks_lines[idx+1][-1]
+            return a+b in ['lr', 'rl']
+        LR_OKs = [LR_OK(p) for p in pair_idx_start]
+        logger.debug('LR_OKs %s'%LR_OKs)
+        if not all(LR_OKs):
+            print('\nError in %s'%tracks_file)
+            print('Some tracks are paired but not L and R: %s'%rawtrx)
+            print('quitting...')
+            quit()
+        complete_pairs_idx = pair_idx_start + [i + 1 for i in pair_idx_start]
+        singles = set(range(len(tracks_lines))).difference(complete_pairs_idx)
+        logger.debug('complete_pairs_idx %s'%complete_pairs_idx)
+        logger.debug('singles %s'%singles)
+        singles_tag = [tracks_lines[i] for i in singles]
+        logger.debug('singles_tag %s'%singles_tag)
+        n_tc_token = sum([t == 'tc' for t in singles_tag])
+        logger.debug('n tc tags %s'%n_tc_token)
+        if n_tc_token == 0:
+            print('\nError in %s'%tracks_file)
+            print('with %s'%rawtrx)
+            print('no TC track found, quitting...')
+            quit()
+        if n_tc_token > 1:
+            print('\nError in %s'%tracks_file)
+            print('with %s'%rawtrx)
+            print('more than one TC track, quitting...')
+            quit()
+        output_tracks = device_scanner.Tracks(None,[],[],[],[],rawtrx,None,[])
+        output_tracks.ttc = tracks_lines.index('tc') + 1 # 1st = 1
+        logger.debug('ttc_chan %s'%output_tracks.ttc)
+        zeroed = [i+1 for i, t in enumerate(tracks_lines) if t == '0']
+        logger.debug('zeroed %s'%zeroed)
+        output_tracks.unused = zeroed
+        output_tracks.others = [(st, tracks_lines.index(st)+1) for st
+                                in singles_tag if st not
+                                in ['tc', 'monomix', '0']]
+        logger.debug('output_tracks.others %s'%output_tracks.others)
+        # check for monomix
+        if 'monomix' in tracks_lines:
+            output_tracks.mix = [tracks_lines.index('monomix')+1]
+        else:
+            output_tracks.mix = []
+        # check for stereo mix
+        def _findLR(i_first):
+            # returns L R indexes (+1 for sox non zero based indexing)
+            i_2nd = i_first + 1
+            a = tracks_lines[i_first][-1] # l|r at end
+            b = tracks_lines[i_2nd][-1] # l|r at end
+            if a == 'l':
+                if b == 'r':
+                    # sequence is mixL mixR
+                    return i_first+1, i_2nd+1
+                else:
+                    print('\nError in %s'%tracks_file)
+                    print('with %s'%rawtrx)
+                    print('can not find stereo mix')
+                    quit()
+            elif a == 'r':
+                if b == 'l':
+                    # sequence is mixR mixL
+                    return i_2nd+1, i_first+1
+                else:
+                    print('\nError in %s'%tracks_file)
+                    print('with %s'%rawtrx)
+                    print('can not find stereo mix')
+                    quit()
+        logger.debug('for now, output_tracks.mix %s'%output_tracks.mix)
+        mix_pair = [p for p in pair_idx_start if tracks_lines[p][1:] == 'mix']
+        if len(mix_pair) == 1:
+            # one stereo mix, remove it from other pairs
+            i = mix_pair[0]
+            LR_pair =  _findLR(i)
+            logger.debug('LR_pair %s'%str(LR_pair))
+            pair_idx_start.remove(i)
+            # consistency check
+            if output_tracks.mix != []:
+                # already found a mono mix above!
+                print('\nError in %s'%tracks_file)
+                print('with %s'%rawtrx)
+                print('found a mono mix AND a stereo mix')
+                quit()
+            output_tracks.mix = LR_pair
+        logger.debug('finally, output_tracks.mix %s'%str(output_tracks.mix))
+        logger.debug('remaining pairs %s'%pair_idx_start)
+        # those are stereo pairs
+        stereo_pairs = []
+        for first_in_pair in pair_idx_start:
+            suffix = tracks_lines[first_in_pair][:-1]
+            stereo_pairs.append((suffix, _findLR(first_in_pair)))
+        logger.debug('stereo_pairs %s'%stereo_pairs)
+        output_tracks.stereomics = stereo_pairs
+        logger.debug('finished: %s'%output_tracks)
+        return output_tracks
+
+    def load_track_info(self):
+        """
+        If audio rec, look for eventual track names in TRACKSFILE file, stored inside the
+        recorder folder alongside the audio files. If there, store a Tracks
+        object into Recording.device.tracks . 
+        """
+        if self.is_video():
+            return
+        source_audio_folder = self.device.folder
+        tracks_file = source_audio_folder/TRACKSFILE
+        track_names = False
+        # a_recording = [m for m in self.found_media_files
+        #                                         if m.device == device][0]
+        # logger.debug('a_recording for device %s : %s'%(device, a_recording))
+        nchan = self.get_audio_channels_nbr()
+        # nchan = sox.file_info.channels(str(a_recording.path))
+        if os.path.isfile(tracks_file):
+            logger.debug('found file: %s'%(TRACKSFILE))
+            tracks = self._find_timed_tracks_(tracks_file)
+            if tracks.error_msg:
+                print('\nError parsing [gold1]%s[/gold1] file: %s, quitting.\n'%
+                    (tracks_file, tracks.error_msg))
+                sys.exit(1)
+            logger.debug('parsed tracks %s'%tracks)
+            ntracks = 2*len(tracks.stereomics)
+            ntracks += len(tracks.mix)
+            ntracks += len(tracks.unused)
+            ntracks += len(tracks.others)
+            ntracks += 1 # for ttc track
+            logger.debug(' n chan: %i n tracks file: %i'%(nchan, ntracks))
+            if ntracks != nchan:
+                print('\nError parsing %s content'%tracks_file)
+                print('incoherent number of tracks, %i vs %i quitting\n'%
+                                                    (nchan, ntracks))
+                sys.exit(1)
+            err_msg = tracks.error_msg
+            if  err_msg != None:
+                print('\nError, quitting: in file %s, %s'%(tracks_file, err_msg))
+                raise Exception
+            else:
+                self.device.tracks = tracks
+                logger.debug('for rec %s'%self)
+                logger.debug('tracks object: %s'%self.device.tracks)
+                return
+        else:
+            logger.debug('no tracks.txt file found')
+            return None
+
     def _ffprobe_audio_stream(self):
         streams = self.probe['streams']
         audio_streams = [

{tictacsync-0.98a0.dist-info → tictacsync-1.4.0b0.dist-info}/METADATA

@@ -1,11 +1,11 @@
 Metadata-Version: 2.1
 Name: tictacsync
-Version: 0.98a0
-Summary: command for syncing audio video recordings
+Version: 1.4.0b0
+Summary: commands for syncing audio video recordings
 Home-page: https://tictacsync.org/
 Author: Raymond Lutz
 Author-email: lutzrayblog@mac.com
-Classifier: Development Status :: 2 - Pre-Alpha
+Classifier: Development Status :: 4 - Beta
 Classifier: Environment :: Console
 Classifier: Intended Audience :: End Users/Desktop
 Classifier: License :: OSI Approved :: MIT License
@@ -26,14 +26,13 @@ Requires-Dist: loguru >=0.6.0
 Requires-Dist: matplotlib >=3.7.1
 Requires-Dist: numpy >=1.24.3
 Requires-Dist: rich >=10.12.0
-Requires-Dist: lmfit
 Requires-Dist: scikit-image
 Requires-Dist: scipy >=1.10.1
 Requires-Dist: platformdirs
 
 # tictacsync
 
-## Warning: this is at pre-alpha stage
+## Warning: this is at beta stage
 
 Unfinished sloppy code ahead, but should run without errors. Some functionalities are still missing. Don't run the code without parental supervision. Suggestions and enquiries are welcome via the [lists hosted on sourcehut](https://sr.ht/~proflutz/TicTacSync/lists).
 
@@ -68,7 +67,7 @@ Then pip install the syncing program:
 This should install python dependencies _and_ the `tictacsync` command.
 ## Usage
 
-Download multiple sample files [here](https://nuage.lutz.quebec/s/NpjzXH5R7DrQEWS/download/dailies.zip) (625 MB, sorry) unzip and run:
+Download multiple sample files [here](https://nuage.lutz.quebec/s/4jw4xgqysLPS8EQ/download/dailies1_3.zip) (700+ MB, sorry) unzip and run:
 
     > tictacsync dailies/loose
 The program `tictacsync` will recursively scan the directory given as argument, find all audio that coincide with any video and merge them into a subfolder named `SyncedMedia`. When the argument is an unique media file (not a directory), no syncing will occur but the decoded starting time will be printed to stdout:

tictacsync-1.4.0b0.dist-info/RECORD

@@ -0,0 +1,24 @@
+tictacsync/LTCcheck.py,sha256=IEfpB_ZajWuRTWtqji0H-B2g7GQvWmGVjfT0Icumv7o,15704
+tictacsync/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tictacsync/device_scanner.py,sha256=YxA3_0O1ZPE1ZuD-OgD-dWhtTWE-LamDhqXXyLo3IMw,26132
+tictacsync/entry.py,sha256=pcGuS4_o0o5dREpcccx1_X3w14PeHdQi5z1Ikzmhpwk,16198
+tictacsync/load_fieldr_reaper.py,sha256=tat0tTZpOyshzVvlqyu1r0u3cpf6TNgK-2C6xJk3_Fw,14708
+tictacsync/mamconf.py,sha256=nfXTwabx-tJmBcpnDR4CRkFe9W4fudzfnbq_nHUg0qE,6424
+tictacsync/mamdav.py,sha256=2we8tfIbJBtDMQdpZZVlCQ9hCQRMbKmV2aU3dDEUf2k,27457
+tictacsync/mamreap.py,sha256=ej7Ap8nbVBCkfah2j5hrE7QBWuqL6Zm-OEsQpNK8mYg,21085
+tictacsync/mamsync.py,sha256=mpoHUAuJWiZ1JfVCECiiSLH_HNdXNV1Z_VlUlJBlPcM,14565
+tictacsync/multi2polywav.py,sha256=qJJhjwIgP1BCTpi2e0wfR95XlgZ2-EIqmefVh-jUBPc,7438
+tictacsync/new-sound-resolve.py,sha256=si7NC_VE_2rNV9jR_Nz_YxK1c92JwzWw5BIWdvLdvAQ,18994
+tictacsync/newmix.py,sha256=-zDxr6_O-rjyo1QfgktvHgwqy_un07eFI4zKi8nygIQ,19188
+tictacsync/remergemix.py,sha256=bRyi1hyNcyM1rTkHh8DmSsIQjYpwPprxSyyVipnxz30,9909
+tictacsync/remrgmx.py,sha256=FxaAo5qqynpj6O56ekQGD31YP6X2g-kEdwVpHSCoh4Q,4265
+tictacsync/splitmix.py,sha256=dpTQYXXCYoertGOXPnMVCrh6xYh390YqmvOHK9hDg90,3148
+tictacsync/synciso.py,sha256=XmUcdUF9rl4VdCm7XW4PeYWYWM0vgAY9dC2hapoul9g,4821
+tictacsync/timeline.py,sha256=ykmB8EfnprQZoEHXRYzriASNWZ7bHfkmQ2-TR6gxZ6Y,75985
+tictacsync/yaltc.py,sha256=xrgL7qokP1A7B_VF4W_BZcC7q9APSmYpmtWH8_t3VWc,68003
+tictacsync-1.4.0b0.dist-info/LICENSE,sha256=ZAOPXLh1zlQAnhHUd7oLslKM01YZ5UiAu3STYjwIxck,1068
+tictacsync-1.4.0b0.dist-info/METADATA,sha256=HMz1ALEb9soZkeMFu0XWdfSTPMhGq_0zVLDiNjZfu1E,5668
+tictacsync-1.4.0b0.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
+tictacsync-1.4.0b0.dist-info/entry_points.txt,sha256=1ymCpiosJdolsqz4yPx8aDbBBePqVt4Zz2m228JkBZ4,211
+tictacsync-1.4.0b0.dist-info/top_level.txt,sha256=eaCWG-BsYTRR-gLTJbK4RfcaXajr0gjQ6wG97MkGRrg,11
+tictacsync-1.4.0b0.dist-info/RECORD,,

tictacsync-1.4.0b0.dist-info/entry_points.txt

@@ -0,0 +1,7 @@
+[console_scripts]
+mamconf = tictacsync.mamconf:main
+mamdav = mamdav:main
+mamreap = mamreap:main
+mamsync = tictacsync.mamsync:main
+multi2polywav = tictacsync.multi2polywav:main
+tictacsync = tictacsync.entry:main

tictacsync-0.98a0.dist-info/RECORD

@@ -1,16 +0,0 @@
-tictacsync/LTCcheck.py,sha256=IEfpB_ZajWuRTWtqji0H-B2g7GQvWmGVjfT0Icumv7o,15704
-tictacsync/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-tictacsync/device_scanner.py,sha256=6XTO4N0ipJ3HNa1I0aSKkTNIgPk_BtCoDDjwCVhOjpI,35446
-tictacsync/entry.py,sha256=KOhB8ivgme3GPpWShad2adS1lvIU9v0yMFY0CELwAmM,20673
-tictacsync/multi2polywav.py,sha256=-nX5reZo6QNxFYdhsliHTs8bTfMjPzcONDT8vJbkZUA,7291
-tictacsync/remergemix.py,sha256=bRyi1hyNcyM1rTkHh8DmSsIQjYpwPprxSyyVipnxz30,9909
-tictacsync/remrgmx.py,sha256=nGuNg55BtXpKTpklwZqunsgVNi-1h-_22OFSnGk7K8k,4340
-tictacsync/synciso.py,sha256=XmUcdUF9rl4VdCm7XW4PeYWYWM0vgAY9dC2hapoul9g,4821
-tictacsync/timeline.py,sha256=2CkTzMDiazYlBq2F1fhM2w4r6CIgmpQk1L2ZvAYRcnA,72532
-tictacsync/yaltc.py,sha256=xbMucI19UJKrEvIzyfpOsi3piSWzqM1gKgooeT9DV8g,53167
-tictacsync-0.98a0.dist-info/LICENSE,sha256=ZAOPXLh1zlQAnhHUd7oLslKM01YZ5UiAu3STYjwIxck,1068
-tictacsync-0.98a0.dist-info/METADATA,sha256=PuGAcwkwrbbkh8wwudBmw4s5DU0kbgKsXJq27dYSXzY,5693
-tictacsync-0.98a0.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
-tictacsync-0.98a0.dist-info/entry_points.txt,sha256=g3tdFFrVRcrKpuyKOCLUVBMgYfV65q9kpLZUOD_XCKg,139
-tictacsync-0.98a0.dist-info/top_level.txt,sha256=eaCWG-BsYTRR-gLTJbK4RfcaXajr0gjQ6wG97MkGRrg,11
-tictacsync-0.98a0.dist-info/RECORD,,

tictacsync-0.98a0.dist-info/entry_points.txt

@@ -1,4 +0,0 @@
-[console_scripts]
-multi2polywav = tictacsync.multi2polywav:main
-remergemix = tictacsync.remergemix:main
-tictacsync = tictacsync.entry:main